← Back to branch summary

~ubuntu-branches/ubuntu/hoary/binutils/hoary

« back to all changes in this revision

Viewing changes to gas/testsuite/gas/h8300/t11_logs.exp

  • Committer: Bazaar Package Importer
  • Author(s): James Troup
  • Date: 2004-05-19 10:35:44 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040519103544-17h3o6e8pwndydrg
Tags: 2.14.90.0.7-8
debian/rules: don't use gcc-2.95 on m68k.  Thanks to Adam Conrad for
pointing this out.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gas/testsuite/gas/h8300/t11_logs.exp
 
1
#
 
2
# Some h8300sx tests -- t11_logs
 
3
#
 
4
 
 
5
proc do_t11_logs_test {} {
 
6
    set testname "t11_logs.s -- h8sx logic tests"
 
7
 
 
8
    gas_start "t11_logs.s" "-al"
 
9
 
 
10
    # Check each instruction bit pattern to verify it got assembled correctly.
 
11
 
 
12
    set x 0
 
13
    expect {
 
14
        -re ".*   7 0000 1701" { set x [expr $x+1]; exp_continue; }
 
15
        -re ".*   8 0002 7D101700" { set x [expr $x+1]; exp_continue; }
 
16
        -re ".*   9 0006 01776818" { set x [expr $x+1]; exp_continue; }
 
17
        -re ".*   9      1700" { set x [expr $x+1]; exp_continue; }
 
18
        -re ".*  10 000c 01746C18" { set x [expr $x+1]; exp_continue; }
 
19
        -re ".*  10      1700" { set x [expr $x+1]; exp_continue; }
 
20
        -re ".*  11 0012 01776C18" { set x [expr $x+1]; exp_continue; }
 
21
        -re ".*  11      1700" { set x [expr $x+1]; exp_continue; }
 
22
        -re ".*  12 0018 01756C18" { set x [expr $x+1]; exp_continue; }
 
23
        -re ".*  12      1700" { set x [expr $x+1]; exp_continue; }
 
24
        -re ".*  13 001e 01766C18" { set x [expr $x+1]; exp_continue; }
 
25
        -re ".*  13      1700" { set x [expr $x+1]; exp_continue; }
 
26
        -re ".*  14 0024 01746E18" { set x [expr $x+1]; exp_continue; }
 
27
        -re ".*  14      12341700" { set x [expr $x+1]; exp_continue; }
 
28
        -re ".*  15 002c 78146A28" { set x [expr $x+1]; exp_continue; }
 
29
        -re ".*  15      12345678" { set x [expr $x+1]; exp_continue; }
 
30
        -re ".*  15      1700" { set x [expr $x+1]; exp_continue; }
 
31
        -re ".*  16 0036 01756E28" { set x [expr $x+1]; exp_continue; }
 
32
        -re ".*  16      12341700" { set x [expr $x+1]; exp_continue; }
 
33
        -re ".*  17 003e 01766E28" { set x [expr $x+1]; exp_continue; }
 
34
        -re ".*  17      12341700" { set x [expr $x+1]; exp_continue; }
 
35
        -re ".*  18 0046 01776E28" { set x [expr $x+1]; exp_continue; }
 
36
        -re ".*  18      12341700" { set x [expr $x+1]; exp_continue; }
 
37
        -re ".*  19 004e 78256A28" { set x [expr $x+1]; exp_continue; }
 
38
        -re ".*  19      12345678" { set x [expr $x+1]; exp_continue; }
 
39
        -re ".*  19      1700" { set x [expr $x+1]; exp_continue; }
 
40
        -re ".*  20 0058 78266A28" { set x [expr $x+1]; exp_continue; }
 
41
        -re ".*  20      12345678" { set x [expr $x+1]; exp_continue; }
 
42
        -re ".*  20      1700" { set x [expr $x+1]; exp_continue; }
 
43
        -re ".*  21 0062 78276A28" { set x [expr $x+1]; exp_continue; }
 
44
        -re ".*  21      12345678" { set x [expr $x+1]; exp_continue; }
 
45
        -re ".*  21      1700" { set x [expr $x+1]; exp_continue; }
 
46
        -re ".*  22 006c 7F121700" { set x [expr $x+1]; exp_continue; }
 
47
        -re ".*  23 0070 6A181234" { set x [expr $x+1]; exp_continue; }
 
48
        -re ".*  23      1700" { set x [expr $x+1]; exp_continue; }
 
49
        -re ".*  24 0076 6A381234" { set x [expr $x+1]; exp_continue; }
 
50
        -re ".*  24      56781700" { set x [expr $x+1]; exp_continue; }
 
51
        -re ".*  25              " {
 
52
            if [expr $x == 37] then {
 
53
                pass "$testname: not.b ..."
 
54
            } else {
 
55
                fail "$testname: not.b ... ($x)"
 
56
            }
 
57
        }
 
58
        default { fail "$testname: not.b ... ($x)" }
 
59
    }
 
60
 
 
61
    set x 0
 
62
    expect {
 
63
        -re ".*  26 007e 1711" { set x [expr $x+1]; exp_continue; }
 
64
        -re ".*  27 0080 7D901710" { set x [expr $x+1]; exp_continue; }
 
65
        -re ".*  28 0084 01576918" { set x [expr $x+1]; exp_continue; }
 
66
        -re ".*  28      1710" { set x [expr $x+1]; exp_continue; }
 
67
        -re ".*  29 008a 01546D18" { set x [expr $x+1]; exp_continue; }
 
68
        -re ".*  29      1710" { set x [expr $x+1]; exp_continue; }
 
69
        -re ".*  30 0090 01576D18" { set x [expr $x+1]; exp_continue; }
 
70
        -re ".*  30      1710" { set x [expr $x+1]; exp_continue; }
 
71
        -re ".*  31 0096 01556D18" { set x [expr $x+1]; exp_continue; }
 
72
        -re ".*  31      1710" { set x [expr $x+1]; exp_continue; }
 
73
        -re ".*  32 009c 01566D18" { set x [expr $x+1]; exp_continue; }
 
74
        -re ".*  32      1710" { set x [expr $x+1]; exp_continue; }
 
75
        -re ".*  33 00a2 01546F18" { set x [expr $x+1]; exp_continue; }
 
76
        -re ".*  33      12341710" { set x [expr $x+1]; exp_continue; }
 
77
        -re ".*  34 00aa 78146B28" { set x [expr $x+1]; exp_continue; }
 
78
        -re ".*  34      12345678" { set x [expr $x+1]; exp_continue; }
 
79
        -re ".*  34      1710" { set x [expr $x+1]; exp_continue; }
 
80
        -re ".*  35 00b4 01556F28" { set x [expr $x+1]; exp_continue; }
 
81
        -re ".*  35      12341710" { set x [expr $x+1]; exp_continue; }
 
82
        -re ".*  36 00bc 01566F28" { set x [expr $x+1]; exp_continue; }
 
83
        -re ".*  36      12341710" { set x [expr $x+1]; exp_continue; }
 
84
        -re ".*  37 00c4 01576F28" { set x [expr $x+1]; exp_continue; }
 
85
        -re ".*  37      12341710" { set x [expr $x+1]; exp_continue; }
 
86
        -re ".*  38 00cc 78256B28" { set x [expr $x+1]; exp_continue; }
 
87
        -re ".*  38      12345678" { set x [expr $x+1]; exp_continue; }
 
88
        -re ".*  38      1710" { set x [expr $x+1]; exp_continue; }
 
89
        -re ".*  39 00d6 78266B28" { set x [expr $x+1]; exp_continue; }
 
90
        -re ".*  39      12345678" { set x [expr $x+1]; exp_continue; }
 
91
        -re ".*  39      1710" { set x [expr $x+1]; exp_continue; }
 
92
        -re ".*  40 00e0 78276B28" { set x [expr $x+1]; exp_continue; }
 
93
        -re ".*  40      12345678" { set x [expr $x+1]; exp_continue; }
 
94
        -re ".*  40      1710" { set x [expr $x+1]; exp_continue; }
 
95
        -re ".*  41 00ea 6B181234" { set x [expr $x+1]; exp_continue; }
 
96
        -re ".*  41      1710" { set x [expr $x+1]; exp_continue; }
 
97
        -re ".*  42 00f0 6B381234" { set x [expr $x+1]; exp_continue; }
 
98
        -re ".*  42      56781710" { set x [expr $x+1]; exp_continue; }
 
99
        -re ".*  43              " {
 
100
            if [expr $x == 36] then {
 
101
                pass "$testname: not.w ..."
 
102
            } else {
 
103
                fail "$testname: not.w ... ($x)"
 
104
            }
 
105
        }
 
106
        default { fail "$testname: not.w ... ($x)" }
 
107
    }
 
108
 
 
109
    set x 0
 
110
    expect {
 
111
        -re ".*  44 00f8 1731" { set x [expr $x+1]; exp_continue; }
 
112
        -re ".*  45 00fa 01046918" { set x [expr $x+1]; exp_continue; }
 
113
        -re ".*  45      1730" { set x [expr $x+1]; exp_continue; }
 
114
        -re ".*  46 0100 01076918" { set x [expr $x+1]; exp_continue; }
 
115
        -re ".*  46      1730" { set x [expr $x+1]; exp_continue; }
 
116
        -re ".*  47 0106 01046D18" { set x [expr $x+1]; exp_continue; }
 
117
        -re ".*  47      1730" { set x [expr $x+1]; exp_continue; }
 
118
        -re ".*  48 010c 01076D18" { set x [expr $x+1]; exp_continue; }
 
119
        -re ".*  48      1730" { set x [expr $x+1]; exp_continue; }
 
120
        -re ".*  49 0112 01056D18" { set x [expr $x+1]; exp_continue; }
 
121
        -re ".*  49      1730" { set x [expr $x+1]; exp_continue; }
 
122
        -re ".*  50 0118 01066D18" { set x [expr $x+1]; exp_continue; }
 
123
        -re ".*  50      1730" { set x [expr $x+1]; exp_continue; }
 
124
        -re ".*  51 011e 01046F18" { set x [expr $x+1]; exp_continue; }
 
125
        -re ".*  51      12341730" { set x [expr $x+1]; exp_continue; }
 
126
        -re ".*  52 0126 78946B28" { set x [expr $x+1]; exp_continue; }
 
127
        -re ".*  52      12345678" { set x [expr $x+1]; exp_continue; }
 
128
        -re ".*  52      1730" { set x [expr $x+1]; exp_continue; }
 
129
        -re ".*  53 0130 01056F28" { set x [expr $x+1]; exp_continue; }
 
130
        -re ".*  53      12341730" { set x [expr $x+1]; exp_continue; }
 
131
        -re ".*  54 0138 01066F28" { set x [expr $x+1]; exp_continue; }
 
132
        -re ".*  54      12341730" { set x [expr $x+1]; exp_continue; }
 
133
        -re ".*  55 0140 01076F28" { set x [expr $x+1]; exp_continue; }
 
134
        -re ".*  55      12341730" { set x [expr $x+1]; exp_continue; }
 
135
        -re ".*  56 0148 78A56B28" { set x [expr $x+1]; exp_continue; }
 
136
        -re ".*  56      12345678" { set x [expr $x+1]; exp_continue; }
 
137
        -re ".*  56      1730" { set x [expr $x+1]; exp_continue; }
 
138
        -re ".*  57 0152 78A66B28" { set x [expr $x+1]; exp_continue; }
 
139
        -re ".*  57      12345678" { set x [expr $x+1]; exp_continue; }
 
140
        -re ".*  57      1730" { set x [expr $x+1]; exp_continue; }
 
141
        -re ".*  58 015c 78A76B28" { set x [expr $x+1]; exp_continue; }
 
142
        -re ".*  58      12345678" { set x [expr $x+1]; exp_continue; }
 
143
        -re ".*  58      1730" { set x [expr $x+1]; exp_continue; }
 
144
        -re ".*  59 0166 01046B08" { set x [expr $x+1]; exp_continue; }
 
145
        -re ".*  59      12341730" { set x [expr $x+1]; exp_continue; }
 
146
        -re ".*  60 016e 01046B28" { set x [expr $x+1]; exp_continue; }
 
147
        -re ".*  60      12345678" { set x [expr $x+1]; exp_continue; }
 
148
        -re ".*  60      1730" { set x [expr $x+1]; exp_continue; }
 
149
        -re ".*  61              " {
 
150
            if [expr $x == 38] then {
 
151
                pass "$testname: not.l ..."
 
152
            } else {
 
153
                fail "$testname: not.l ... ($x)"
 
154
            }
 
155
        }
 
156
        default { fail "$testname: not.l ... ($x)" }
 
157
    }
 
158
 
 
159
    set x 0
 
160
    expect {
 
161
        -re ".*  62 0178 1001" { set x [expr $x+1]; exp_continue; }
 
162
        -re ".*  63 017a 7D101000" { set x [expr $x+1]; exp_continue; }
 
163
        -re ".*  64 017e 01776818" { set x [expr $x+1]; exp_continue; }
 
164
        -re ".*  64      1000" { set x [expr $x+1]; exp_continue; }
 
165
        -re ".*  65 0184 01746C18" { set x [expr $x+1]; exp_continue; }
 
166
        -re ".*  65      1000" { set x [expr $x+1]; exp_continue; }
 
167
        -re ".*  66 018a 01776C18" { set x [expr $x+1]; exp_continue; }
 
168
        -re ".*  66      1000" { set x [expr $x+1]; exp_continue; }
 
169
        -re ".*  67 0190 01756C18" { set x [expr $x+1]; exp_continue; }
 
170
        -re ".*  67      1000" { set x [expr $x+1]; exp_continue; }
 
171
        -re ".*  68 0196 01766C18" { set x [expr $x+1]; exp_continue; }
 
172
        -re ".*  68      1000" { set x [expr $x+1]; exp_continue; }
 
173
        -re ".*  69 019c 01746E18" { set x [expr $x+1]; exp_continue; }
 
174
        -re ".*  69      12341000" { set x [expr $x+1]; exp_continue; }
 
175
        -re ".*  70 01a4 78146A28" { set x [expr $x+1]; exp_continue; }
 
176
        -re ".*  70      12345678" { set x [expr $x+1]; exp_continue; }
 
177
        -re ".*  70      1000" { set x [expr $x+1]; exp_continue; }
 
178
        -re ".*  71 01ae 01756E28" { set x [expr $x+1]; exp_continue; }
 
179
        -re ".*  71      12341000" { set x [expr $x+1]; exp_continue; }
 
180
        -re ".*  72 01b6 01766E28" { set x [expr $x+1]; exp_continue; }
 
181
        -re ".*  72      12341000" { set x [expr $x+1]; exp_continue; }
 
182
        -re ".*  73 01be 01776E28" { set x [expr $x+1]; exp_continue; }
 
183
        -re ".*  73      12341000" { set x [expr $x+1]; exp_continue; }
 
184
        -re ".*  74 01c6 78256A28" { set x [expr $x+1]; exp_continue; }
 
185
        -re ".*  74      12345678" { set x [expr $x+1]; exp_continue; }
 
186
        -re ".*  74      1000" { set x [expr $x+1]; exp_continue; }
 
187
        -re ".*  75 01d0 78266A28" { set x [expr $x+1]; exp_continue; }
 
188
        -re ".*  75      12345678" { set x [expr $x+1]; exp_continue; }
 
189
        -re ".*  75      1000" { set x [expr $x+1]; exp_continue; }
 
190
        -re ".*  76 01da 78276A28" { set x [expr $x+1]; exp_continue; }
 
191
        -re ".*  76      12345678" { set x [expr $x+1]; exp_continue; }
 
192
        -re ".*  76      1000" { set x [expr $x+1]; exp_continue; }
 
193
        -re ".*  77 01e4 7F121000" { set x [expr $x+1]; exp_continue; }
 
194
        -re ".*  78 01e8 6A181234" { set x [expr $x+1]; exp_continue; }
 
195
        -re ".*  78      1000" { set x [expr $x+1]; exp_continue; }
 
196
        -re ".*  79 01ee 6A381234" { set x [expr $x+1]; exp_continue; }
 
197
        -re ".*  79      56781000" { set x [expr $x+1]; exp_continue; }
 
198
        -re ".*  80              " {
 
199
            if [expr $x == 37] then {
 
200
                pass "$testname: shll.b ..."
 
201
            } else {
 
202
                fail "$testname: shll.b ... ($x)"
 
203
            }
 
204
        }
 
205
        default { fail "$testname: shll.b ... ($x)" }
 
206
    }
 
207
 
 
208
    set x 0
 
209
    expect {
 
210
        -re ".*  81 01f6 1011" { set x [expr $x+1]; exp_continue; }
 
211
        -re ".*  82 01f8 7D901010" { set x [expr $x+1]; exp_continue; }
 
212
        -re ".*  83 01fc 01576918" { set x [expr $x+1]; exp_continue; }
 
213
        -re ".*  83      1010" { set x [expr $x+1]; exp_continue; }
 
214
        -re ".*  84 0202 01546D18" { set x [expr $x+1]; exp_continue; }
 
215
        -re ".*  84      1010" { set x [expr $x+1]; exp_continue; }
 
216
        -re ".*  85 0208 01576D18" { set x [expr $x+1]; exp_continue; }
 
217
        -re ".*  85      1010" { set x [expr $x+1]; exp_continue; }
 
218
        -re ".*  86 020e 01556D18" { set x [expr $x+1]; exp_continue; }
 
219
        -re ".*  86      1010" { set x [expr $x+1]; exp_continue; }
 
220
        -re ".*  87 0214 01566D18" { set x [expr $x+1]; exp_continue; }
 
221
        -re ".*  87      1010" { set x [expr $x+1]; exp_continue; }
 
222
        -re ".*  88 021a 01546F18" { set x [expr $x+1]; exp_continue; }
 
223
        -re ".*  88      12341010" { set x [expr $x+1]; exp_continue; }
 
224
        -re ".*  89 0222 78146B28" { set x [expr $x+1]; exp_continue; }
 
225
        -re ".*  89      12345678" { set x [expr $x+1]; exp_continue; }
 
226
        -re ".*  89      1010" { set x [expr $x+1]; exp_continue; }
 
227
        -re ".*  90 022c 01556F28" { set x [expr $x+1]; exp_continue; }
 
228
        -re ".*  90      12341010" { set x [expr $x+1]; exp_continue; }
 
229
        -re ".*  91 0234 01566F28" { set x [expr $x+1]; exp_continue; }
 
230
        -re ".*  91      12341010" { set x [expr $x+1]; exp_continue; }
 
231
        -re ".*  92 023c 01576F28" { set x [expr $x+1]; exp_continue; }
 
232
        -re ".*  92      12341010" { set x [expr $x+1]; exp_continue; }
 
233
        -re ".*  93 0244 78256B28" { set x [expr $x+1]; exp_continue; }
 
234
        -re ".*  93      12345678" { set x [expr $x+1]; exp_continue; }
 
235
        -re ".*  93      1010" { set x [expr $x+1]; exp_continue; }
 
236
        -re ".*  94 024e 78266B28" { set x [expr $x+1]; exp_continue; }
 
237
        -re ".*  94      12345678" { set x [expr $x+1]; exp_continue; }
 
238
        -re ".*  94      1010" { set x [expr $x+1]; exp_continue; }
 
239
        -re ".*  95 0258 78276B28" { set x [expr $x+1]; exp_continue; }
 
240
        -re ".*  95      12345678" { set x [expr $x+1]; exp_continue; }
 
241
        -re ".*  95      1010" { set x [expr $x+1]; exp_continue; }
 
242
        -re ".*  96 0262 6B181234" { set x [expr $x+1]; exp_continue; }
 
243
        -re ".*  96      1010" { set x [expr $x+1]; exp_continue; }
 
244
        -re ".*  97 0268 6B381234" { set x [expr $x+1]; exp_continue; }
 
245
        -re ".*  97      56781010" { set x [expr $x+1]; exp_continue; }
 
246
        -re ".*  98              " {
 
247
            if [expr $x == 36] then {
 
248
                pass "$testname: shll.w ..."
 
249
            } else {
 
250
                fail "$testname: shll.w ... ($x)"
 
251
            }
 
252
        }
 
253
        default { fail "$testname: shll.w ... ($x)" }
 
254
    }
 
255
 
 
256
    set x 0
 
257
    expect {
 
258
        -re ".*  99 0270 1031" { set x [expr $x+1]; exp_continue; }
 
259
        -re ".* 100 0272 01046918" { set x [expr $x+1]; exp_continue; }
 
260
        -re ".* 100      1030" { set x [expr $x+1]; exp_continue; }
 
261
        -re ".* 101 0278 01076918" { set x [expr $x+1]; exp_continue; }
 
262
        -re ".* 101      1030" { set x [expr $x+1]; exp_continue; }
 
263
        -re ".* 102 027e 01046D18" { set x [expr $x+1]; exp_continue; }
 
264
        -re ".* 102      1030" { set x [expr $x+1]; exp_continue; }
 
265
        -re ".* 103 0284 01076D18" { set x [expr $x+1]; exp_continue; }
 
266
        -re ".* 103      1030" { set x [expr $x+1]; exp_continue; }
 
267
        -re ".* 104 028a 01056D18" { set x [expr $x+1]; exp_continue; }
 
268
        -re ".* 104      1030" { set x [expr $x+1]; exp_continue; }
 
269
        -re ".* 105 0290 01066D18" { set x [expr $x+1]; exp_continue; }
 
270
        -re ".* 105      1030" { set x [expr $x+1]; exp_continue; }
 
271
        -re ".* 106 0296 01046F18" { set x [expr $x+1]; exp_continue; }
 
272
        -re ".* 106      12341030" { set x [expr $x+1]; exp_continue; }
 
273
        -re ".* 107 029e 78946B28" { set x [expr $x+1]; exp_continue; }
 
274
        -re ".* 107      12345678" { set x [expr $x+1]; exp_continue; }
 
275
        -re ".* 107      1030" { set x [expr $x+1]; exp_continue; }
 
276
        -re ".* 108 02a8 01056F28" { set x [expr $x+1]; exp_continue; }
 
277
        -re ".* 108      12341030" { set x [expr $x+1]; exp_continue; }
 
278
        -re ".* 109 02b0 01066F28" { set x [expr $x+1]; exp_continue; }
 
279
        -re ".* 109      12341030" { set x [expr $x+1]; exp_continue; }
 
280
        -re ".* 110 02b8 01076F28" { set x [expr $x+1]; exp_continue; }
 
281
        -re ".* 110      12341030" { set x [expr $x+1]; exp_continue; }
 
282
        -re ".* 111 02c0 78A56B28" { set x [expr $x+1]; exp_continue; }
 
283
        -re ".* 111      12345678" { set x [expr $x+1]; exp_continue; }
 
284
        -re ".* 111      1030" { set x [expr $x+1]; exp_continue; }
 
285
        -re ".* 112 02ca 78A66B28" { set x [expr $x+1]; exp_continue; }
 
286
        -re ".* 112      12345678" { set x [expr $x+1]; exp_continue; }
 
287
        -re ".* 112      1030" { set x [expr $x+1]; exp_continue; }
 
288
        -re ".* 113 02d4 78A76B28" { set x [expr $x+1]; exp_continue; }
 
289
        -re ".* 113      12345678" { set x [expr $x+1]; exp_continue; }
 
290
        -re ".* 113      1030" { set x [expr $x+1]; exp_continue; }
 
291
        -re ".* 114 02de 01046B08" { set x [expr $x+1]; exp_continue; }
 
292
        -re ".* 114      12341030" { set x [expr $x+1]; exp_continue; }
 
293
        -re ".* 115 02e6 01046B28" { set x [expr $x+1]; exp_continue; }
 
294
        -re ".* 115      12345678" { set x [expr $x+1]; exp_continue; }
 
295
        -re ".* 115      1030" { set x [expr $x+1]; exp_continue; }
 
296
        -re ".* 116              " {
 
297
            if [expr $x == 38] then {
 
298
                pass "$testname: shll.l ..."
 
299
            } else {
 
300
                fail "$testname: shll.l ... ($x)"
 
301
            }
 
302
        }
 
303
        default { fail "$testname: shll.l ... ($x)" }
 
304
    }
 
305
 
 
306
    set x 0
 
307
    expect {
 
308
        -re ".* 117 02f0 1041" { set x [expr $x+1]; exp_continue; }
 
309
        -re ".* 118 02f2 7D101040" { set x [expr $x+1]; exp_continue; }
 
310
        -re ".* 119 02f6 01776818" { set x [expr $x+1]; exp_continue; }
 
311
        -re ".* 119      1040" { set x [expr $x+1]; exp_continue; }
 
312
        -re ".* 120 02fc 01746C18" { set x [expr $x+1]; exp_continue; }
 
313
        -re ".* 120      1040" { set x [expr $x+1]; exp_continue; }
 
314
        -re ".* 121 0302 01776C18" { set x [expr $x+1]; exp_continue; }
 
315
        -re ".* 121      1040" { set x [expr $x+1]; exp_continue; }
 
316
        -re ".* 122 0308 01756C18" { set x [expr $x+1]; exp_continue; }
 
317
        -re ".* 122      1040" { set x [expr $x+1]; exp_continue; }
 
318
        -re ".* 123 030e 01766C18" { set x [expr $x+1]; exp_continue; }
 
319
        -re ".* 123      1040" { set x [expr $x+1]; exp_continue; }
 
320
        -re ".* 124 0314 01746E18" { set x [expr $x+1]; exp_continue; }
 
321
        -re ".* 124      12341040" { set x [expr $x+1]; exp_continue; }
 
322
        -re ".* 125 031c 78146A28" { set x [expr $x+1]; exp_continue; }
 
323
        -re ".* 125      12345678" { set x [expr $x+1]; exp_continue; }
 
324
        -re ".* 125      1040" { set x [expr $x+1]; exp_continue; }
 
325
        -re ".* 126 0326 01756E28" { set x [expr $x+1]; exp_continue; }
 
326
        -re ".* 126      12341040" { set x [expr $x+1]; exp_continue; }
 
327
        -re ".* 127 032e 01766E28" { set x [expr $x+1]; exp_continue; }
 
328
        -re ".* 127      12341040" { set x [expr $x+1]; exp_continue; }
 
329
        -re ".* 128 0336 01776E28" { set x [expr $x+1]; exp_continue; }
 
330
        -re ".* 128      12341040" { set x [expr $x+1]; exp_continue; }
 
331
        -re ".* 129 033e 78256A28" { set x [expr $x+1]; exp_continue; }
 
332
        -re ".* 129      12345678" { set x [expr $x+1]; exp_continue; }
 
333
        -re ".* 129      1040" { set x [expr $x+1]; exp_continue; }
 
334
        -re ".* 130 0348 78266A28" { set x [expr $x+1]; exp_continue; }
 
335
        -re ".* 130      12345678" { set x [expr $x+1]; exp_continue; }
 
336
        -re ".* 130      1040" { set x [expr $x+1]; exp_continue; }
 
337
        -re ".* 131 0352 78276A28" { set x [expr $x+1]; exp_continue; }
 
338
        -re ".* 131      12345678" { set x [expr $x+1]; exp_continue; }
 
339
        -re ".* 131      1040" { set x [expr $x+1]; exp_continue; }
 
340
        -re ".* 132 035c 7F121040" { set x [expr $x+1]; exp_continue; }
 
341
        -re ".* 133 0360 6A181234" { set x [expr $x+1]; exp_continue; }
 
342
        -re ".* 133      1040" { set x [expr $x+1]; exp_continue; }
 
343
        -re ".* 134 0366 6A381234" { set x [expr $x+1]; exp_continue; }
 
344
        -re ".* 134      56781040" { set x [expr $x+1]; exp_continue; }
 
345
        -re ".* 135              " {
 
346
            if [expr $x == 37] then {
 
347
                pass "$testname: shll.b #2, ..."
 
348
            } else {
 
349
                fail "$testname: shll.b #2, ... ($x)"
 
350
            }
 
351
        }
 
352
        default { fail "$testname: shll.b #2, ... ($x)" }
 
353
    }
 
354
 
 
355
    set x 0
 
356
    expect {
 
357
        -re ".* 136 036e 1051" { set x [expr $x+1]; exp_continue; }
 
358
        -re ".* 137 0370 7D901050" { set x [expr $x+1]; exp_continue; }
 
359
        -re ".* 138 0374 01576918" { set x [expr $x+1]; exp_continue; }
 
360
        -re ".* 138      1050" { set x [expr $x+1]; exp_continue; }
 
361
        -re ".* 139 037a 01546D18" { set x [expr $x+1]; exp_continue; }
 
362
        -re ".* 139      1050" { set x [expr $x+1]; exp_continue; }
 
363
        -re ".* 140 0380 01576D18" { set x [expr $x+1]; exp_continue; }
 
364
        -re ".* 140      1050" { set x [expr $x+1]; exp_continue; }
 
365
        -re ".* 141 0386 01556D18" { set x [expr $x+1]; exp_continue; }
 
366
        -re ".* 141      1050" { set x [expr $x+1]; exp_continue; }
 
367
        -re ".* 142 038c 01566D18" { set x [expr $x+1]; exp_continue; }
 
368
        -re ".* 142      1050" { set x [expr $x+1]; exp_continue; }
 
369
        -re ".* 143 0392 01546F18" { set x [expr $x+1]; exp_continue; }
 
370
        -re ".* 143      12341050" { set x [expr $x+1]; exp_continue; }
 
371
        -re ".* 144 039a 78146B28" { set x [expr $x+1]; exp_continue; }
 
372
        -re ".* 144      12345678" { set x [expr $x+1]; exp_continue; }
 
373
        -re ".* 144      1050" { set x [expr $x+1]; exp_continue; }
 
374
        -re ".* 145 03a4 01556F28" { set x [expr $x+1]; exp_continue; }
 
375
        -re ".* 145      12341050" { set x [expr $x+1]; exp_continue; }
 
376
        -re ".* 146 03ac 01566F28" { set x [expr $x+1]; exp_continue; }
 
377
        -re ".* 146      12341050" { set x [expr $x+1]; exp_continue; }
 
378
        -re ".* 147 03b4 01576F28" { set x [expr $x+1]; exp_continue; }
 
379
        -re ".* 147      12341050" { set x [expr $x+1]; exp_continue; }
 
380
        -re ".* 148 03bc 78256B28" { set x [expr $x+1]; exp_continue; }
 
381
        -re ".* 148      12345678" { set x [expr $x+1]; exp_continue; }
 
382
        -re ".* 148      1050" { set x [expr $x+1]; exp_continue; }
 
383
        -re ".* 149 03c6 78266B28" { set x [expr $x+1]; exp_continue; }
 
384
        -re ".* 149      12345678" { set x [expr $x+1]; exp_continue; }
 
385
        -re ".* 149      1050" { set x [expr $x+1]; exp_continue; }
 
386
        -re ".* 150 03d0 78276B28" { set x [expr $x+1]; exp_continue; }
 
387
        -re ".* 150      12345678" { set x [expr $x+1]; exp_continue; }
 
388
        -re ".* 150      1050" { set x [expr $x+1]; exp_continue; }
 
389
        -re ".* 151 03da 6B181234" { set x [expr $x+1]; exp_continue; }
 
390
        -re ".* 151      1050" { set x [expr $x+1]; exp_continue; }
 
391
        -re ".* 152 03e0 6B381234" { set x [expr $x+1]; exp_continue; }
 
392
        -re ".* 152      56781050" { set x [expr $x+1]; exp_continue; }
 
393
        -re ".* 153              " {
 
394
            if [expr $x == 36] then {
 
395
                pass "$testname: shll.w #2, ..."
 
396
            } else {
 
397
                fail "$testname: shll.w #2, ... ($x)"
 
398
            }
 
399
        }
 
400
        default { fail "$testname: shll.w #2, ... ($x)" }
 
401
    }
 
402
 
 
403
    set x 0
 
404
    expect {
 
405
        -re ".* 154 03e8 1071" { set x [expr $x+1]; exp_continue; }
 
406
        -re ".* 155 03ea 01046918" { set x [expr $x+1]; exp_continue; }
 
407
        -re ".* 155      1070" { set x [expr $x+1]; exp_continue; }
 
408
        -re ".* 156 03f0 01076918" { set x [expr $x+1]; exp_continue; }
 
409
        -re ".* 156      1070" { set x [expr $x+1]; exp_continue; }
 
410
        -re ".* 157 03f6 01046D18" { set x [expr $x+1]; exp_continue; }
 
411
        -re ".* 157      1070" { set x [expr $x+1]; exp_continue; }
 
412
        -re ".* 158 03fc 01076D18" { set x [expr $x+1]; exp_continue; }
 
413
        -re ".* 158      1070" { set x [expr $x+1]; exp_continue; }
 
414
        -re ".* 159 0402 01056D18" { set x [expr $x+1]; exp_continue; }
 
415
        -re ".* 159      1070" { set x [expr $x+1]; exp_continue; }
 
416
        -re ".* 160 0408 01066D18" { set x [expr $x+1]; exp_continue; }
 
417
        -re ".* 160      1070" { set x [expr $x+1]; exp_continue; }
 
418
        -re ".* 161 040e 01046F18" { set x [expr $x+1]; exp_continue; }
 
419
        -re ".* 161      12341070" { set x [expr $x+1]; exp_continue; }
 
420
        -re ".* 162 0416 78946B28" { set x [expr $x+1]; exp_continue; }
 
421
        -re ".* 162      12345678" { set x [expr $x+1]; exp_continue; }
 
422
        -re ".* 162      1070" { set x [expr $x+1]; exp_continue; }
 
423
        -re ".* 163 0420 01056F28" { set x [expr $x+1]; exp_continue; }
 
424
        -re ".* 163      12341070" { set x [expr $x+1]; exp_continue; }
 
425
        -re ".* 164 0428 01066F28" { set x [expr $x+1]; exp_continue; }
 
426
        -re ".* 164      12341070" { set x [expr $x+1]; exp_continue; }
 
427
        -re ".* 165 0430 01076F28" { set x [expr $x+1]; exp_continue; }
 
428
        -re ".* 165      12341070" { set x [expr $x+1]; exp_continue; }
 
429
        -re ".* 166 0438 78A56B28" { set x [expr $x+1]; exp_continue; }
 
430
        -re ".* 166      12345678" { set x [expr $x+1]; exp_continue; }
 
431
        -re ".* 166      1070" { set x [expr $x+1]; exp_continue; }
 
432
        -re ".* 167 0442 78A66B28" { set x [expr $x+1]; exp_continue; }
 
433
        -re ".* 167      12345678" { set x [expr $x+1]; exp_continue; }
 
434
        -re ".* 167      1070" { set x [expr $x+1]; exp_continue; }
 
435
        -re ".* 168 044c 78A76B28" { set x [expr $x+1]; exp_continue; }
 
436
        -re ".* 168      12345678" { set x [expr $x+1]; exp_continue; }
 
437
        -re ".* 168      1070" { set x [expr $x+1]; exp_continue; }
 
438
        -re ".* 169 0456 01046B08" { set x [expr $x+1]; exp_continue; }
 
439
        -re ".* 169      12341070" { set x [expr $x+1]; exp_continue; }
 
440
        -re ".* 170 045e 01046B28" { set x [expr $x+1]; exp_continue; }
 
441
        -re ".* 170      12345678" { set x [expr $x+1]; exp_continue; }
 
442
        -re ".* 170      1070" { set x [expr $x+1]; exp_continue; }
 
443
        -re ".* 171              " {
 
444
            if [expr $x == 38] then {
 
445
                pass "$testname: shll.l #2, ..."
 
446
            } else {
 
447
                fail "$testname: shll.l #2, ... ($x)"
 
448
            }
 
449
        }
 
450
        default { fail "$testname: shll.l #2, ... ($x)" }
 
451
    }
 
452
 
 
453
    set x 0
 
454
    expect {
 
455
        -re ".* 172 0468 10A1" { set x [expr $x+1]; exp_continue; }
 
456
        -re ".* 173 046a 7D1010A0" { set x [expr $x+1]; exp_continue; }
 
457
        -re ".* 174 046e 01776818" { set x [expr $x+1]; exp_continue; }
 
458
        -re ".* 174      10A0" { set x [expr $x+1]; exp_continue; }
 
459
        -re ".* 175 0474 01746C18" { set x [expr $x+1]; exp_continue; }
 
460
        -re ".* 175      10A0" { set x [expr $x+1]; exp_continue; }
 
461
        -re ".* 176 047a 01776C18" { set x [expr $x+1]; exp_continue; }
 
462
        -re ".* 176      10A0" { set x [expr $x+1]; exp_continue; }
 
463
        -re ".* 177 0480 01756C18" { set x [expr $x+1]; exp_continue; }
 
464
        -re ".* 177      10A0" { set x [expr $x+1]; exp_continue; }
 
465
        -re ".* 178 0486 01766C18" { set x [expr $x+1]; exp_continue; }
 
466
        -re ".* 178      10A0" { set x [expr $x+1]; exp_continue; }
 
467
        -re ".* 179 048c 01746E18" { set x [expr $x+1]; exp_continue; }
 
468
        -re ".* 179      123410A0" { set x [expr $x+1]; exp_continue; }
 
469
        -re ".* 180 0494 78146A28" { set x [expr $x+1]; exp_continue; }
 
470
        -re ".* 180      12345678" { set x [expr $x+1]; exp_continue; }
 
471
        -re ".* 180      10A0" { set x [expr $x+1]; exp_continue; }
 
472
        -re ".* 181 049e 01756E28" { set x [expr $x+1]; exp_continue; }
 
473
        -re ".* 181      123410A0" { set x [expr $x+1]; exp_continue; }
 
474
        -re ".* 182 04a6 01766E28" { set x [expr $x+1]; exp_continue; }
 
475
        -re ".* 182      123410A0" { set x [expr $x+1]; exp_continue; }
 
476
        -re ".* 183 04ae 01776E28" { set x [expr $x+1]; exp_continue; }
 
477
        -re ".* 183      123410A0" { set x [expr $x+1]; exp_continue; }
 
478
        -re ".* 184 04b6 78256A28" { set x [expr $x+1]; exp_continue; }
 
479
        -re ".* 184      12345678" { set x [expr $x+1]; exp_continue; }
 
480
        -re ".* 184      10A0" { set x [expr $x+1]; exp_continue; }
 
481
        -re ".* 185 04c0 78266A28" { set x [expr $x+1]; exp_continue; }
 
482
        -re ".* 185      12345678" { set x [expr $x+1]; exp_continue; }
 
483
        -re ".* 185      10A0" { set x [expr $x+1]; exp_continue; }
 
484
        -re ".* 186 04ca 78276A28" { set x [expr $x+1]; exp_continue; }
 
485
        -re ".* 186      12345678" { set x [expr $x+1]; exp_continue; }
 
486
        -re ".* 186      10A0" { set x [expr $x+1]; exp_continue; }
 
487
        -re ".* 187 04d4 7F1210A0" { set x [expr $x+1]; exp_continue; }
 
488
        -re ".* 188 04d8 6A181234" { set x [expr $x+1]; exp_continue; }
 
489
        -re ".* 188      10A0" { set x [expr $x+1]; exp_continue; }
 
490
        -re ".* 189 04de 6A381234" { set x [expr $x+1]; exp_continue; }
 
491
        -re ".* 189      567810A0" { set x [expr $x+1]; exp_continue; }
 
492
        -re ".* 190              " {
 
493
            if [expr $x == 37] then {
 
494
                pass "$testname: shll.b #4, ..."
 
495
            } else {
 
496
                fail "$testname: shll.b #4, ... ($x)"
 
497
            }
 
498
        }
 
499
        default { fail "$testname: shll.b #4, ... ($x)" }
 
500
    }
 
501
 
 
502
    set x 0
 
503
    expect {
 
504
        -re ".* 191 04e6 1021" { set x [expr $x+1]; exp_continue; }
 
505
        -re ".* 192 04e8 7D901020" { set x [expr $x+1]; exp_continue; }
 
506
        -re ".* 193 04ec 01576918" { set x [expr $x+1]; exp_continue; }
 
507
        -re ".* 193      1020" { set x [expr $x+1]; exp_continue; }
 
508
        -re ".* 194 04f2 01546D18" { set x [expr $x+1]; exp_continue; }
 
509
        -re ".* 194      1020" { set x [expr $x+1]; exp_continue; }
 
510
        -re ".* 195 04f8 01576D18" { set x [expr $x+1]; exp_continue; }
 
511
        -re ".* 195      1020" { set x [expr $x+1]; exp_continue; }
 
512
        -re ".* 196 04fe 01556D18" { set x [expr $x+1]; exp_continue; }
 
513
        -re ".* 196      1020" { set x [expr $x+1]; exp_continue; }
 
514
        -re ".* 197 0504 01566D18" { set x [expr $x+1]; exp_continue; }
 
515
        -re ".* 197      1020" { set x [expr $x+1]; exp_continue; }
 
516
        -re ".* 198 050a 01546F18" { set x [expr $x+1]; exp_continue; }
 
517
        -re ".* 198      12341020" { set x [expr $x+1]; exp_continue; }
 
518
        -re ".* 199 0512 78146B28" { set x [expr $x+1]; exp_continue; }
 
519
        -re ".* 199      12345678" { set x [expr $x+1]; exp_continue; }
 
520
        -re ".* 199      1020" { set x [expr $x+1]; exp_continue; }
 
521
        -re ".* 200 051c 01556F28" { set x [expr $x+1]; exp_continue; }
 
522
        -re ".* 200      12341020" { set x [expr $x+1]; exp_continue; }
 
523
        -re ".* 201 0524 01566F28" { set x [expr $x+1]; exp_continue; }
 
524
        -re ".* 201      12341020" { set x [expr $x+1]; exp_continue; }
 
525
        -re ".* 202 052c 01576F28" { set x [expr $x+1]; exp_continue; }
 
526
        -re ".* 202      12341020" { set x [expr $x+1]; exp_continue; }
 
527
        -re ".* 203 0534 78256B28" { set x [expr $x+1]; exp_continue; }
 
528
        -re ".* 203      12345678" { set x [expr $x+1]; exp_continue; }
 
529
        -re ".* 203      1020" { set x [expr $x+1]; exp_continue; }
 
530
        -re ".* 204 053e 78266B28" { set x [expr $x+1]; exp_continue; }
 
531
        -re ".* 204      12345678" { set x [expr $x+1]; exp_continue; }
 
532
        -re ".* 204      1020" { set x [expr $x+1]; exp_continue; }
 
533
        -re ".* 205 0548 78276B28" { set x [expr $x+1]; exp_continue; }
 
534
        -re ".* 205      12345678" { set x [expr $x+1]; exp_continue; }
 
535
        -re ".* 205      1020" { set x [expr $x+1]; exp_continue; }
 
536
        -re ".* 206 0552 6B181234" { set x [expr $x+1]; exp_continue; }
 
537
        -re ".* 206      1020" { set x [expr $x+1]; exp_continue; }
 
538
        -re ".* 207 0558 6B381234" { set x [expr $x+1]; exp_continue; }
 
539
        -re ".* 207      56781020" { set x [expr $x+1]; exp_continue; }
 
540
        -re ".* 208              " {
 
541
            if [expr $x == 36] then {
 
542
                pass "$testname: shll.w #4, ..."
 
543
            } else {
 
544
                fail "$testname: shll.w #4, ... ($x)"
 
545
            }
 
546
        }
 
547
        default { fail "$testname: shll.w #4, ... ($x)" }
 
548
    }
 
549
 
 
550
    set x 0
 
551
    expect {
 
552
        -re ".* 209 0560 1039" { set x [expr $x+1]; exp_continue; }
 
553
        -re ".* 210 0562 01046918" { set x [expr $x+1]; exp_continue; }
 
554
        -re ".* 210      1038" { set x [expr $x+1]; exp_continue; }
 
555
        -re ".* 211 0568 01076918" { set x [expr $x+1]; exp_continue; }
 
556
        -re ".* 211      1038" { set x [expr $x+1]; exp_continue; }
 
557
        -re ".* 212 056e 01046D18" { set x [expr $x+1]; exp_continue; }
 
558
        -re ".* 212      1038" { set x [expr $x+1]; exp_continue; }
 
559
        -re ".* 213 0574 01076D18" { set x [expr $x+1]; exp_continue; }
 
560
        -re ".* 213      1038" { set x [expr $x+1]; exp_continue; }
 
561
        -re ".* 214 057a 01056D18" { set x [expr $x+1]; exp_continue; }
 
562
        -re ".* 214      1038" { set x [expr $x+1]; exp_continue; }
 
563
        -re ".* 215 0580 01066D18" { set x [expr $x+1]; exp_continue; }
 
564
        -re ".* 215      1038" { set x [expr $x+1]; exp_continue; }
 
565
        -re ".* 216 0586 01046F18" { set x [expr $x+1]; exp_continue; }
 
566
        -re ".* 216      12341038" { set x [expr $x+1]; exp_continue; }
 
567
        -re ".* 217 058e 78946B28" { set x [expr $x+1]; exp_continue; }
 
568
        -re ".* 217      12345678" { set x [expr $x+1]; exp_continue; }
 
569
        -re ".* 217      1038" { set x [expr $x+1]; exp_continue; }
 
570
        -re ".* 218 0598 01056F28" { set x [expr $x+1]; exp_continue; }
 
571
        -re ".* 218      12341038" { set x [expr $x+1]; exp_continue; }
 
572
        -re ".* 219 05a0 01066F28" { set x [expr $x+1]; exp_continue; }
 
573
        -re ".* 219      12341038" { set x [expr $x+1]; exp_continue; }
 
574
        -re ".* 220 05a8 01076F28" { set x [expr $x+1]; exp_continue; }
 
575
        -re ".* 220      12341038" { set x [expr $x+1]; exp_continue; }
 
576
        -re ".* 221 05b0 78A56B28" { set x [expr $x+1]; exp_continue; }
 
577
        -re ".* 221      12345678" { set x [expr $x+1]; exp_continue; }
 
578
        -re ".* 221      1038" { set x [expr $x+1]; exp_continue; }
 
579
        -re ".* 222 05ba 78A66B28" { set x [expr $x+1]; exp_continue; }
 
580
        -re ".* 222      12345678" { set x [expr $x+1]; exp_continue; }
 
581
        -re ".* 222      1038" { set x [expr $x+1]; exp_continue; }
 
582
        -re ".* 223 05c4 78A76B28" { set x [expr $x+1]; exp_continue; }
 
583
        -re ".* 223      12345678" { set x [expr $x+1]; exp_continue; }
 
584
        -re ".* 223      1038" { set x [expr $x+1]; exp_continue; }
 
585
        -re ".* 224 05ce 01046B08" { set x [expr $x+1]; exp_continue; }
 
586
        -re ".* 224      12341038" { set x [expr $x+1]; exp_continue; }
 
587
        -re ".* 225 05d6 01046B28" { set x [expr $x+1]; exp_continue; }
 
588
        -re ".* 225      12345678" { set x [expr $x+1]; exp_continue; }
 
589
        -re ".* 225      1038" { set x [expr $x+1]; exp_continue; }
 
590
        -re ".* 226              " {
 
591
            if [expr $x == 38] then {
 
592
                pass "$testname: shll.l #4, ..."
 
593
            } else {
 
594
                fail "$testname: shll.l #4, ... ($x)"
 
595
            }
 
596
        }
 
597
        default { fail "$testname: shll.l #4, ... ($x)" }
 
598
    }
 
599
 
 
600
    set x 0
 
601
    expect {
 
602
        -re ".* 227 05e0 1061" { set x [expr $x+1]; exp_continue; }
 
603
        -re ".* 228 05e2 7D901060" { set x [expr $x+1]; exp_continue; }
 
604
        -re ".* 229 05e6 01576918" { set x [expr $x+1]; exp_continue; }
 
605
        -re ".* 229      1060" { set x [expr $x+1]; exp_continue; }
 
606
        -re ".* 230 05ec 01546D18" { set x [expr $x+1]; exp_continue; }
 
607
        -re ".* 230      1060" { set x [expr $x+1]; exp_continue; }
 
608
        -re ".* 231 05f2 01576D18" { set x [expr $x+1]; exp_continue; }
 
609
        -re ".* 231      1060" { set x [expr $x+1]; exp_continue; }
 
610
        -re ".* 232 05f8 01556D18" { set x [expr $x+1]; exp_continue; }
 
611
        -re ".* 232      1060" { set x [expr $x+1]; exp_continue; }
 
612
        -re ".* 233 05fe 01566D18" { set x [expr $x+1]; exp_continue; }
 
613
        -re ".* 233      1060" { set x [expr $x+1]; exp_continue; }
 
614
        -re ".* 234 0604 01546F18" { set x [expr $x+1]; exp_continue; }
 
615
        -re ".* 234      12341060" { set x [expr $x+1]; exp_continue; }
 
616
        -re ".* 235 060c 78146B28" { set x [expr $x+1]; exp_continue; }
 
617
        -re ".* 235      12345678" { set x [expr $x+1]; exp_continue; }
 
618
        -re ".* 235      1060" { set x [expr $x+1]; exp_continue; }
 
619
        -re ".* 236 0616 01556F28" { set x [expr $x+1]; exp_continue; }
 
620
        -re ".* 236      12341060" { set x [expr $x+1]; exp_continue; }
 
621
        -re ".* 237 061e 01566F28" { set x [expr $x+1]; exp_continue; }
 
622
        -re ".* 237      12341060" { set x [expr $x+1]; exp_continue; }
 
623
        -re ".* 238 0626 01576F28" { set x [expr $x+1]; exp_continue; }
 
624
        -re ".* 238      12341060" { set x [expr $x+1]; exp_continue; }
 
625
        -re ".* 239 062e 78256B28" { set x [expr $x+1]; exp_continue; }
 
626
        -re ".* 239      12345678" { set x [expr $x+1]; exp_continue; }
 
627
        -re ".* 239      1060" { set x [expr $x+1]; exp_continue; }
 
628
        -re ".* 240 0638 78266B28" { set x [expr $x+1]; exp_continue; }
 
629
        -re ".* 240      12345678" { set x [expr $x+1]; exp_continue; }
 
630
        -re ".* 240      1060" { set x [expr $x+1]; exp_continue; }
 
631
        -re ".* 241 0642 78276B28" { set x [expr $x+1]; exp_continue; }
 
632
        -re ".* 241      12345678" { set x [expr $x+1]; exp_continue; }
 
633
        -re ".* 241      1060" { set x [expr $x+1]; exp_continue; }
 
634
        -re ".* 242 064c 6B181234" { set x [expr $x+1]; exp_continue; }
 
635
        -re ".* 242      1060" { set x [expr $x+1]; exp_continue; }
 
636
        -re ".* 243 0652 6B381234" { set x [expr $x+1]; exp_continue; }
 
637
        -re ".* 243      56781060" { set x [expr $x+1]; exp_continue; }
 
638
        -re ".* 244              " {
 
639
            if [expr $x == 36] then {
 
640
                pass "$testname: shll.w #8, ..."
 
641
            } else {
 
642
                fail "$testname: shll.w #8, ... ($x)"
 
643
            }
 
644
        }
 
645
        default { fail "$testname: shll.w #8, ... ($x)" }
 
646
    }
 
647
 
 
648
    set x 0
 
649
    expect {
 
650
        -re ".* 245 065a 1079" { set x [expr $x+1]; exp_continue; }
 
651
        -re ".* 246 065c 01046918" { set x [expr $x+1]; exp_continue; }
 
652
        -re ".* 246      1078" { set x [expr $x+1]; exp_continue; }
 
653
        -re ".* 247 0662 01076918" { set x [expr $x+1]; exp_continue; }
 
654
        -re ".* 247      1078" { set x [expr $x+1]; exp_continue; }
 
655
        -re ".* 248 0668 01046D18" { set x [expr $x+1]; exp_continue; }
 
656
        -re ".* 248      1078" { set x [expr $x+1]; exp_continue; }
 
657
        -re ".* 249 066e 01076D18" { set x [expr $x+1]; exp_continue; }
 
658
        -re ".* 249      1078" { set x [expr $x+1]; exp_continue; }
 
659
        -re ".* 250 0674 01056D18" { set x [expr $x+1]; exp_continue; }
 
660
        -re ".* 250      1078" { set x [expr $x+1]; exp_continue; }
 
661
        -re ".* 251 067a 01066D18" { set x [expr $x+1]; exp_continue; }
 
662
        -re ".* 251      1078" { set x [expr $x+1]; exp_continue; }
 
663
        -re ".* 252 0680 01046F18" { set x [expr $x+1]; exp_continue; }
 
664
        -re ".* 252      12341078" { set x [expr $x+1]; exp_continue; }
 
665
        -re ".* 253 0688 78946B28" { set x [expr $x+1]; exp_continue; }
 
666
        -re ".* 253      12345678" { set x [expr $x+1]; exp_continue; }
 
667
        -re ".* 253      1078" { set x [expr $x+1]; exp_continue; }
 
668
        -re ".* 254 0692 01056F28" { set x [expr $x+1]; exp_continue; }
 
669
        -re ".* 254      12341078" { set x [expr $x+1]; exp_continue; }
 
670
        -re ".* 255 069a 01066F28" { set x [expr $x+1]; exp_continue; }
 
671
        -re ".* 255      12341078" { set x [expr $x+1]; exp_continue; }
 
672
        -re ".* 256 06a2 01076F28" { set x [expr $x+1]; exp_continue; }
 
673
        -re ".* 256      12341078" { set x [expr $x+1]; exp_continue; }
 
674
        -re ".* 257 06aa 78A56B28" { set x [expr $x+1]; exp_continue; }
 
675
        -re ".* 257      12345678" { set x [expr $x+1]; exp_continue; }
 
676
        -re ".* 257      1078" { set x [expr $x+1]; exp_continue; }
 
677
        -re ".* 258 06b4 78A66B28" { set x [expr $x+1]; exp_continue; }
 
678
        -re ".* 258      12345678" { set x [expr $x+1]; exp_continue; }
 
679
        -re ".* 258      1078" { set x [expr $x+1]; exp_continue; }
 
680
        -re ".* 259 06be 78A76B28" { set x [expr $x+1]; exp_continue; }
 
681
        -re ".* 259      12345678" { set x [expr $x+1]; exp_continue; }
 
682
        -re ".* 259      1078" { set x [expr $x+1]; exp_continue; }
 
683
        -re ".* 260 06c8 01046B08" { set x [expr $x+1]; exp_continue; }
 
684
        -re ".* 260      12341078" { set x [expr $x+1]; exp_continue; }
 
685
        -re ".* 261 06d0 01046B28" { set x [expr $x+1]; exp_continue; }
 
686
        -re ".* 261      12345678" { set x [expr $x+1]; exp_continue; }
 
687
        -re ".* 261      1078" { set x [expr $x+1]; exp_continue; }
 
688
        -re ".* 262              " {
 
689
            if [expr $x == 38] then {
 
690
                pass "$testname: shll.l #8, ..."
 
691
            } else {
 
692
                fail "$testname: shll.l #8, ... ($x)"
 
693
            }
 
694
        }
 
695
        default { fail "$testname: shll.l #8, ... ($x)" }
 
696
    }
 
697
 
 
698
    set x 0
 
699
    expect {
 
700
        -re ".* 263 06da 10F9" { set x [expr $x+1]; exp_continue; }
 
701
        -re ".* 264 06dc 01046918" { set x [expr $x+1]; exp_continue; }
 
702
        -re ".* 264      10F8" { set x [expr $x+1]; exp_continue; }
 
703
        -re ".* 265 06e2 01076918" { set x [expr $x+1]; exp_continue; }
 
704
        -re ".* 265      10F8" { set x [expr $x+1]; exp_continue; }
 
705
        -re ".* 266 06e8 01046D18" { set x [expr $x+1]; exp_continue; }
 
706
        -re ".* 266      10F8" { set x [expr $x+1]; exp_continue; }
 
707
        -re ".* 267 06ee 01076D18" { set x [expr $x+1]; exp_continue; }
 
708
        -re ".* 267      10F8" { set x [expr $x+1]; exp_continue; }
 
709
        -re ".* 268 06f4 01056D18" { set x [expr $x+1]; exp_continue; }
 
710
        -re ".* 268      10F8" { set x [expr $x+1]; exp_continue; }
 
711
        -re ".* 269 06fa 01066D18" { set x [expr $x+1]; exp_continue; }
 
712
        -re ".* 269      10F8" { set x [expr $x+1]; exp_continue; }
 
713
        -re ".* 270 0700 01046F18" { set x [expr $x+1]; exp_continue; }
 
714
        -re ".* 270      123410F8" { set x [expr $x+1]; exp_continue; }
 
715
        -re ".* 271 0708 78946B28" { set x [expr $x+1]; exp_continue; }
 
716
        -re ".* 271      12345678" { set x [expr $x+1]; exp_continue; }
 
717
        -re ".* 271      10F8" { set x [expr $x+1]; exp_continue; }
 
718
        -re ".* 272 0712 01056F28" { set x [expr $x+1]; exp_continue; }
 
719
        -re ".* 272      123410F8" { set x [expr $x+1]; exp_continue; }
 
720
        -re ".* 273 071a 01066F28" { set x [expr $x+1]; exp_continue; }
 
721
        -re ".* 273      123410F8" { set x [expr $x+1]; exp_continue; }
 
722
        -re ".* 274 0722 01076F28" { set x [expr $x+1]; exp_continue; }
 
723
        -re ".* 274      123410F8" { set x [expr $x+1]; exp_continue; }
 
724
        -re ".* 275 072a 78A56B28" { set x [expr $x+1]; exp_continue; }
 
725
        -re ".* 275      12345678" { set x [expr $x+1]; exp_continue; }
 
726
        -re ".* 275      10F8" { set x [expr $x+1]; exp_continue; }
 
727
        -re ".* 276 0734 78A66B28" { set x [expr $x+1]; exp_continue; }
 
728
        -re ".* 276      12345678" { set x [expr $x+1]; exp_continue; }
 
729
        -re ".* 276      10F8" { set x [expr $x+1]; exp_continue; }
 
730
        -re ".* 277 073e 78A76B28" { set x [expr $x+1]; exp_continue; }
 
731
        -re ".* 277      12345678" { set x [expr $x+1]; exp_continue; }
 
732
        -re ".* 277      10F8" { set x [expr $x+1]; exp_continue; }
 
733
        -re ".* 278 0748 01046B08" { set x [expr $x+1]; exp_continue; }
 
734
        -re ".* 278      123410F8" { set x [expr $x+1]; exp_continue; }
 
735
        -re ".* 279 0750 01046B28" { set x [expr $x+1]; exp_continue; }
 
736
        -re ".* 279      12345678" { set x [expr $x+1]; exp_continue; }
 
737
        -re ".* 279      10F8" { set x [expr $x+1]; exp_continue; }
 
738
        -re ".* 280              " {
 
739
            if [expr $x == 38] then {
 
740
                pass "$testname: shll.l #16, ..."
 
741
            } else {
 
742
                fail "$testname: shll.l #16, ... ($x)"
 
743
            }
 
744
        }
 
745
        default { fail "$testname: shll.l #16, ... ($x)" }
 
746
    }
 
747
 
 
748
    set x 0
 
749
    expect {
 
750
        -re ".* 281 075a 03871001" { set x [expr $x+1]; exp_continue; }
 
751
        -re ".* 282 075e 038F1011" { set x [expr $x+1]; exp_continue; }
 
752
        -re ".* 283 0762 039F1031" { set x [expr $x+1]; exp_continue; }
 
753
        -re ".* 284              " {
 
754
            if [expr $x == 3] then {
 
755
                pass "$testname: shll.? #imm:5, <reg>"
 
756
            } else {
 
757
                fail "$testname: shll.? #imm:5, <reg> ($x)"
 
758
            }
 
759
        }
 
760
        default { fail "$testname: shll.? #imm:5, <reg> ($x)" }
 
761
    }
 
762
 
 
763
    set x 0
 
764
    expect {
 
765
        -re ".* 285 0766 78381001" { set x [expr $x+1]; exp_continue; }
 
766
        -re ".* 286 076a 78381011" { set x [expr $x+1]; exp_continue; }
 
767
        -re ".* 287 076e 78381031" { set x [expr $x+1]; exp_continue; }
 
768
        -re ".* 288              " {
 
769
            if [expr $x == 3] then {
 
770
                pass "$testname: shll.? r3h, <reg>"
 
771
            } else {
 
772
                fail "$testname: shll.? r3h, <reg> ($x)"
 
773
            }
 
774
        }
 
775
        default { fail "$testname: shll.? r3h, <reg> ($x)" }
 
776
    }
 
777
 
 
778
    set x 0
 
779
    expect {
 
780
        -re ".* 289 0772 1101" { set x [expr $x+1]; exp_continue; }
 
781
        -re ".* 290 0774 7D101100" { set x [expr $x+1]; exp_continue; }
 
782
        -re ".* 291 0778 01776818" { set x [expr $x+1]; exp_continue; }
 
783
        -re ".* 291      1100" { set x [expr $x+1]; exp_continue; }
 
784
        -re ".* 292 077e 01746C18" { set x [expr $x+1]; exp_continue; }
 
785
        -re ".* 292      1100" { set x [expr $x+1]; exp_continue; }
 
786
        -re ".* 293 0784 01776C18" { set x [expr $x+1]; exp_continue; }
 
787
        -re ".* 293      1100" { set x [expr $x+1]; exp_continue; }
 
788
        -re ".* 294 078a 01756C18" { set x [expr $x+1]; exp_continue; }
 
789
        -re ".* 294      1100" { set x [expr $x+1]; exp_continue; }
 
790
        -re ".* 295 0790 01766C18" { set x [expr $x+1]; exp_continue; }
 
791
        -re ".* 295      1100" { set x [expr $x+1]; exp_continue; }
 
792
        -re ".* 296 0796 01746E18" { set x [expr $x+1]; exp_continue; }
 
793
        -re ".* 296      12341100" { set x [expr $x+1]; exp_continue; }
 
794
        -re ".* 297 079e 78146A28" { set x [expr $x+1]; exp_continue; }
 
795
        -re ".* 297      12345678" { set x [expr $x+1]; exp_continue; }
 
796
        -re ".* 297      1100" { set x [expr $x+1]; exp_continue; }
 
797
        -re ".* 298 07a8 01756E28" { set x [expr $x+1]; exp_continue; }
 
798
        -re ".* 298      12341100" { set x [expr $x+1]; exp_continue; }
 
799
        -re ".* 299 07b0 01766E28" { set x [expr $x+1]; exp_continue; }
 
800
        -re ".* 299      12341100" { set x [expr $x+1]; exp_continue; }
 
801
        -re ".* 300 07b8 01776E28" { set x [expr $x+1]; exp_continue; }
 
802
        -re ".* 300      12341100" { set x [expr $x+1]; exp_continue; }
 
803
        -re ".* 301 07c0 78256A28" { set x [expr $x+1]; exp_continue; }
 
804
        -re ".* 301      12345678" { set x [expr $x+1]; exp_continue; }
 
805
        -re ".* 301      1100" { set x [expr $x+1]; exp_continue; }
 
806
        -re ".* 302 07ca 78266A28" { set x [expr $x+1]; exp_continue; }
 
807
        -re ".* 302      12345678" { set x [expr $x+1]; exp_continue; }
 
808
        -re ".* 302      1100" { set x [expr $x+1]; exp_continue; }
 
809
        -re ".* 303 07d4 78276A28" { set x [expr $x+1]; exp_continue; }
 
810
        -re ".* 303      12345678" { set x [expr $x+1]; exp_continue; }
 
811
        -re ".* 303      1100" { set x [expr $x+1]; exp_continue; }
 
812
        -re ".* 304 07de 7F121100" { set x [expr $x+1]; exp_continue; }
 
813
        -re ".* 305 07e2 6A181234" { set x [expr $x+1]; exp_continue; }
 
814
        -re ".* 305      1100" { set x [expr $x+1]; exp_continue; }
 
815
        -re ".* 306 07e8 6A381234" { set x [expr $x+1]; exp_continue; }
 
816
        -re ".* 306      56781100" { set x [expr $x+1]; exp_continue; }
 
817
        -re ".* 307              " {
 
818
            if [expr $x == 37] then {
 
819
                pass "$testname: shlr.b ..."
 
820
            } else {
 
821
                fail "$testname: shlr.b ... ($x)"
 
822
            }
 
823
        }
 
824
        default { fail "$testname: shlr.b ... ($x)" }
 
825
    }
 
826
 
 
827
    set x 0
 
828
    expect {
 
829
        -re ".* 308 07f0 1111" { set x [expr $x+1]; exp_continue; }
 
830
        -re ".* 309 07f2 7D901110" { set x [expr $x+1]; exp_continue; }
 
831
        -re ".* 310 07f6 01576918" { set x [expr $x+1]; exp_continue; }
 
832
        -re ".* 310      1110" { set x [expr $x+1]; exp_continue; }
 
833
        -re ".* 311 07fc 01546D18" { set x [expr $x+1]; exp_continue; }
 
834
        -re ".* 311      1110" { set x [expr $x+1]; exp_continue; }
 
835
        -re ".* 312 0802 01576D18" { set x [expr $x+1]; exp_continue; }
 
836
        -re ".* 312      1110" { set x [expr $x+1]; exp_continue; }
 
837
        -re ".* 313 0808 01556D18" { set x [expr $x+1]; exp_continue; }
 
838
        -re ".* 313      1110" { set x [expr $x+1]; exp_continue; }
 
839
        -re ".* 314 080e 01566D18" { set x [expr $x+1]; exp_continue; }
 
840
        -re ".* 314      1110" { set x [expr $x+1]; exp_continue; }
 
841
        -re ".* 315 0814 01546F18" { set x [expr $x+1]; exp_continue; }
 
842
        -re ".* 315      12341110" { set x [expr $x+1]; exp_continue; }
 
843
        -re ".* 316 081c 78146B28" { set x [expr $x+1]; exp_continue; }
 
844
        -re ".* 316      12345678" { set x [expr $x+1]; exp_continue; }
 
845
        -re ".* 316      1110" { set x [expr $x+1]; exp_continue; }
 
846
        -re ".* 317 0826 01556F28" { set x [expr $x+1]; exp_continue; }
 
847
        -re ".* 317      12341110" { set x [expr $x+1]; exp_continue; }
 
848
        -re ".* 318 082e 01566F28" { set x [expr $x+1]; exp_continue; }
 
849
        -re ".* 318      12341110" { set x [expr $x+1]; exp_continue; }
 
850
        -re ".* 319 0836 01576F28" { set x [expr $x+1]; exp_continue; }
 
851
        -re ".* 319      12341110" { set x [expr $x+1]; exp_continue; }
 
852
        -re ".* 320 083e 78256B28" { set x [expr $x+1]; exp_continue; }
 
853
        -re ".* 320      12345678" { set x [expr $x+1]; exp_continue; }
 
854
        -re ".* 320      1110" { set x [expr $x+1]; exp_continue; }
 
855
        -re ".* 321 0848 78266B28" { set x [expr $x+1]; exp_continue; }
 
856
        -re ".* 321      12345678" { set x [expr $x+1]; exp_continue; }
 
857
        -re ".* 321      1110" { set x [expr $x+1]; exp_continue; }
 
858
        -re ".* 322 0852 78276B28" { set x [expr $x+1]; exp_continue; }
 
859
        -re ".* 322      12345678" { set x [expr $x+1]; exp_continue; }
 
860
        -re ".* 322      1110" { set x [expr $x+1]; exp_continue; }
 
861
        -re ".* 323 085c 6B181234" { set x [expr $x+1]; exp_continue; }
 
862
        -re ".* 323      1110" { set x [expr $x+1]; exp_continue; }
 
863
        -re ".* 324 0862 6B381234" { set x [expr $x+1]; exp_continue; }
 
864
        -re ".* 324      56781110" { set x [expr $x+1]; exp_continue; }
 
865
        -re ".* 325              " {
 
866
            if [expr $x == 36] then {
 
867
                pass "$testname: shlr.w ..."
 
868
            } else {
 
869
                fail "$testname: shlr.w ... ($x)"
 
870
            }
 
871
        }
 
872
        default { fail "$testname: shlr.w ... ($x)" }
 
873
    }
 
874
 
 
875
    set x 0
 
876
    expect {
 
877
        -re ".* 326 086a 1131" { set x [expr $x+1]; exp_continue; }
 
878
        -re ".* 327 086c 01046918" { set x [expr $x+1]; exp_continue; }
 
879
        -re ".* 327      1130" { set x [expr $x+1]; exp_continue; }
 
880
        -re ".* 328 0872 01076918" { set x [expr $x+1]; exp_continue; }
 
881
        -re ".* 328      1130" { set x [expr $x+1]; exp_continue; }
 
882
        -re ".* 329 0878 01046D18" { set x [expr $x+1]; exp_continue; }
 
883
        -re ".* 329      1130" { set x [expr $x+1]; exp_continue; }
 
884
        -re ".* 330 087e 01076D18" { set x [expr $x+1]; exp_continue; }
 
885
        -re ".* 330      1130" { set x [expr $x+1]; exp_continue; }
 
886
        -re ".* 331 0884 01056D18" { set x [expr $x+1]; exp_continue; }
 
887
        -re ".* 331      1130" { set x [expr $x+1]; exp_continue; }
 
888
        -re ".* 332 088a 01066D18" { set x [expr $x+1]; exp_continue; }
 
889
        -re ".* 332      1130" { set x [expr $x+1]; exp_continue; }
 
890
        -re ".* 333 0890 01046F18" { set x [expr $x+1]; exp_continue; }
 
891
        -re ".* 333      12341130" { set x [expr $x+1]; exp_continue; }
 
892
        -re ".* 334 0898 78946B28" { set x [expr $x+1]; exp_continue; }
 
893
        -re ".* 334      12345678" { set x [expr $x+1]; exp_continue; }
 
894
        -re ".* 334      1130" { set x [expr $x+1]; exp_continue; }
 
895
        -re ".* 335 08a2 01056F28" { set x [expr $x+1]; exp_continue; }
 
896
        -re ".* 335      12341130" { set x [expr $x+1]; exp_continue; }
 
897
        -re ".* 336 08aa 01066F28" { set x [expr $x+1]; exp_continue; }
 
898
        -re ".* 336      12341130" { set x [expr $x+1]; exp_continue; }
 
899
        -re ".* 337 08b2 01076F28" { set x [expr $x+1]; exp_continue; }
 
900
        -re ".* 337      12341130" { set x [expr $x+1]; exp_continue; }
 
901
        -re ".* 338 08ba 78A56B28" { set x [expr $x+1]; exp_continue; }
 
902
        -re ".* 338      12345678" { set x [expr $x+1]; exp_continue; }
 
903
        -re ".* 338      1130" { set x [expr $x+1]; exp_continue; }
 
904
        -re ".* 339 08c4 78A66B28" { set x [expr $x+1]; exp_continue; }
 
905
        -re ".* 339      12345678" { set x [expr $x+1]; exp_continue; }
 
906
        -re ".* 339      1130" { set x [expr $x+1]; exp_continue; }
 
907
        -re ".* 340 08ce 78A76B28" { set x [expr $x+1]; exp_continue; }
 
908
        -re ".* 340      12345678" { set x [expr $x+1]; exp_continue; }
 
909
        -re ".* 340      1130" { set x [expr $x+1]; exp_continue; }
 
910
        -re ".* 341 08d8 01046B08" { set x [expr $x+1]; exp_continue; }
 
911
        -re ".* 341      12341130" { set x [expr $x+1]; exp_continue; }
 
912
        -re ".* 342 08e0 01046B28" { set x [expr $x+1]; exp_continue; }
 
913
        -re ".* 342      12345678" { set x [expr $x+1]; exp_continue; }
 
914
        -re ".* 342      1130" { set x [expr $x+1]; exp_continue; }
 
915
        -re ".* 343              " {
 
916
            if [expr $x == 38] then {
 
917
                pass "$testname: shlr.l ..."
 
918
            } else {
 
919
                fail "$testname: shlr.l ... ($x)"
 
920
            }
 
921
        }
 
922
        default { fail "$testname: shlr.l ... ($x)" }
 
923
    }
 
924
 
 
925
    set x 0
 
926
    expect {
 
927
        -re ".* 344 08ea 1141" { set x [expr $x+1]; exp_continue; }
 
928
        -re ".* 345 08ec 7D101140" { set x [expr $x+1]; exp_continue; }
 
929
        -re ".* 346 08f0 01776818" { set x [expr $x+1]; exp_continue; }
 
930
        -re ".* 346      1140" { set x [expr $x+1]; exp_continue; }
 
931
        -re ".* 347 08f6 01746C18" { set x [expr $x+1]; exp_continue; }
 
932
        -re ".* 347      1140" { set x [expr $x+1]; exp_continue; }
 
933
        -re ".* 348 08fc 01776C18" { set x [expr $x+1]; exp_continue; }
 
934
        -re ".* 348      1140" { set x [expr $x+1]; exp_continue; }
 
935
        -re ".* 349 0902 01756C18" { set x [expr $x+1]; exp_continue; }
 
936
        -re ".* 349      1140" { set x [expr $x+1]; exp_continue; }
 
937
        -re ".* 350 0908 01766C18" { set x [expr $x+1]; exp_continue; }
 
938
        -re ".* 350      1140" { set x [expr $x+1]; exp_continue; }
 
939
        -re ".* 351 090e 01746E18" { set x [expr $x+1]; exp_continue; }
 
940
        -re ".* 351      12341140" { set x [expr $x+1]; exp_continue; }
 
941
        -re ".* 352 0916 78146A28" { set x [expr $x+1]; exp_continue; }
 
942
        -re ".* 352      12345678" { set x [expr $x+1]; exp_continue; }
 
943
        -re ".* 352      1140" { set x [expr $x+1]; exp_continue; }
 
944
        -re ".* 353 0920 01756E28" { set x [expr $x+1]; exp_continue; }
 
945
        -re ".* 353      12341140" { set x [expr $x+1]; exp_continue; }
 
946
        -re ".* 354 0928 01766E28" { set x [expr $x+1]; exp_continue; }
 
947
        -re ".* 354      12341140" { set x [expr $x+1]; exp_continue; }
 
948
        -re ".* 355 0930 01776E28" { set x [expr $x+1]; exp_continue; }
 
949
        -re ".* 355      12341140" { set x [expr $x+1]; exp_continue; }
 
950
        -re ".* 356 0938 78256A28" { set x [expr $x+1]; exp_continue; }
 
951
        -re ".* 356      12345678" { set x [expr $x+1]; exp_continue; }
 
952
        -re ".* 356      1140" { set x [expr $x+1]; exp_continue; }
 
953
        -re ".* 357 0942 78266A28" { set x [expr $x+1]; exp_continue; }
 
954
        -re ".* 357      12345678" { set x [expr $x+1]; exp_continue; }
 
955
        -re ".* 357      1140" { set x [expr $x+1]; exp_continue; }
 
956
        -re ".* 358 094c 78276A28" { set x [expr $x+1]; exp_continue; }
 
957
        -re ".* 358      12345678" { set x [expr $x+1]; exp_continue; }
 
958
        -re ".* 358      1140" { set x [expr $x+1]; exp_continue; }
 
959
        -re ".* 359 0956 7F121140" { set x [expr $x+1]; exp_continue; }
 
960
        -re ".* 360 095a 6A181234" { set x [expr $x+1]; exp_continue; }
 
961
        -re ".* 360      1140" { set x [expr $x+1]; exp_continue; }
 
962
        -re ".* 361 0960 6A381234" { set x [expr $x+1]; exp_continue; }
 
963
        -re ".* 361      56781140" { set x [expr $x+1]; exp_continue; }
 
964
        -re ".* 362              " {
 
965
            if [expr $x == 37] then {
 
966
                pass "$testname: shlr.b #2, ..."
 
967
            } else {
 
968
                fail "$testname: shlr.b #2, ... ($x)"
 
969
            }
 
970
        }
 
971
        default { fail "$testname: shlr.b #2, ... ($x)" }
 
972
    }
 
973
 
 
974
    set x 0
 
975
    expect {
 
976
        -re ".* 363 0968 1151" { set x [expr $x+1]; exp_continue; }
 
977
        -re ".* 364 096a 7D901150" { set x [expr $x+1]; exp_continue; }
 
978
        -re ".* 365 096e 01576918" { set x [expr $x+1]; exp_continue; }
 
979
        -re ".* 365      1150" { set x [expr $x+1]; exp_continue; }
 
980
        -re ".* 366 0974 01546D18" { set x [expr $x+1]; exp_continue; }
 
981
        -re ".* 366      1150" { set x [expr $x+1]; exp_continue; }
 
982
        -re ".* 367 097a 01576D18" { set x [expr $x+1]; exp_continue; }
 
983
        -re ".* 367      1150" { set x [expr $x+1]; exp_continue; }
 
984
        -re ".* 368 0980 01556D18" { set x [expr $x+1]; exp_continue; }
 
985
        -re ".* 368      1150" { set x [expr $x+1]; exp_continue; }
 
986
        -re ".* 369 0986 01566D18" { set x [expr $x+1]; exp_continue; }
 
987
        -re ".* 369      1150" { set x [expr $x+1]; exp_continue; }
 
988
        -re ".* 370 098c 01546F18" { set x [expr $x+1]; exp_continue; }
 
989
        -re ".* 370      12341150" { set x [expr $x+1]; exp_continue; }
 
990
        -re ".* 371 0994 78146B28" { set x [expr $x+1]; exp_continue; }
 
991
        -re ".* 371      12345678" { set x [expr $x+1]; exp_continue; }
 
992
        -re ".* 371      1150" { set x [expr $x+1]; exp_continue; }
 
993
        -re ".* 372 099e 01556F28" { set x [expr $x+1]; exp_continue; }
 
994
        -re ".* 372      12341150" { set x [expr $x+1]; exp_continue; }
 
995
        -re ".* 373 09a6 01566F28" { set x [expr $x+1]; exp_continue; }
 
996
        -re ".* 373      12341150" { set x [expr $x+1]; exp_continue; }
 
997
        -re ".* 374 09ae 01576F28" { set x [expr $x+1]; exp_continue; }
 
998
        -re ".* 374      12341150" { set x [expr $x+1]; exp_continue; }
 
999
        -re ".* 375 09b6 78256B28" { set x [expr $x+1]; exp_continue; }
 
1000
        -re ".* 375      12345678" { set x [expr $x+1]; exp_continue; }
 
1001
        -re ".* 375      1150" { set x [expr $x+1]; exp_continue; }
 
1002
        -re ".* 376 09c0 78266B28" { set x [expr $x+1]; exp_continue; }
 
1003
        -re ".* 376      12345678" { set x [expr $x+1]; exp_continue; }
 
1004
        -re ".* 376      1150" { set x [expr $x+1]; exp_continue; }
 
1005
        -re ".* 377 09ca 78276B28" { set x [expr $x+1]; exp_continue; }
 
1006
        -re ".* 377      12345678" { set x [expr $x+1]; exp_continue; }
 
1007
        -re ".* 377      1150" { set x [expr $x+1]; exp_continue; }
 
1008
        -re ".* 378 09d4 6B181234" { set x [expr $x+1]; exp_continue; }
 
1009
        -re ".* 378      1150" { set x [expr $x+1]; exp_continue; }
 
1010
        -re ".* 379 09da 6B381234" { set x [expr $x+1]; exp_continue; }
 
1011
        -re ".* 379      56781150" { set x [expr $x+1]; exp_continue; }
 
1012
        -re ".* 380              " {
 
1013
            if [expr $x == 36] then {
 
1014
                pass "$testname: shlr.w #2, ..."
 
1015
            } else {
 
1016
                fail "$testname: shlr.w #2, ... ($x)"
 
1017
            }
 
1018
        }
 
1019
        default { fail "$testname: shlr.w #2, ... ($x)" }
 
1020
    }
 
1021
 
 
1022
    set x 0
 
1023
    expect {
 
1024
        -re ".* 381 09e2 1171" { set x [expr $x+1]; exp_continue; }
 
1025
        -re ".* 382 09e4 01046918" { set x [expr $x+1]; exp_continue; }
 
1026
        -re ".* 382      1170" { set x [expr $x+1]; exp_continue; }
 
1027
        -re ".* 383 09ea 01076918" { set x [expr $x+1]; exp_continue; }
 
1028
        -re ".* 383      1170" { set x [expr $x+1]; exp_continue; }
 
1029
        -re ".* 384 09f0 01046D18" { set x [expr $x+1]; exp_continue; }
 
1030
        -re ".* 384      1170" { set x [expr $x+1]; exp_continue; }
 
1031
        -re ".* 385 09f6 01076D18" { set x [expr $x+1]; exp_continue; }
 
1032
        -re ".* 385      1170" { set x [expr $x+1]; exp_continue; }
 
1033
        -re ".* 386 09fc 01056D18" { set x [expr $x+1]; exp_continue; }
 
1034
        -re ".* 386      1170" { set x [expr $x+1]; exp_continue; }
 
1035
        -re ".* 387 0a02 01066D18" { set x [expr $x+1]; exp_continue; }
 
1036
        -re ".* 387      1170" { set x [expr $x+1]; exp_continue; }
 
1037
        -re ".* 388 0a08 01046F18" { set x [expr $x+1]; exp_continue; }
 
1038
        -re ".* 388      12341170" { set x [expr $x+1]; exp_continue; }
 
1039
        -re ".* 389 0a10 78946B28" { set x [expr $x+1]; exp_continue; }
 
1040
        -re ".* 389      12345678" { set x [expr $x+1]; exp_continue; }
 
1041
        -re ".* 389      1170" { set x [expr $x+1]; exp_continue; }
 
1042
        -re ".* 390 0a1a 01056F28" { set x [expr $x+1]; exp_continue; }
 
1043
        -re ".* 390      12341170" { set x [expr $x+1]; exp_continue; }
 
1044
        -re ".* 391 0a22 01066F28" { set x [expr $x+1]; exp_continue; }
 
1045
        -re ".* 391      12341170" { set x [expr $x+1]; exp_continue; }
 
1046
        -re ".* 392 0a2a 01076F28" { set x [expr $x+1]; exp_continue; }
 
1047
        -re ".* 392      12341170" { set x [expr $x+1]; exp_continue; }
 
1048
        -re ".* 393 0a32 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1049
        -re ".* 393      12345678" { set x [expr $x+1]; exp_continue; }
 
1050
        -re ".* 393      1170" { set x [expr $x+1]; exp_continue; }
 
1051
        -re ".* 394 0a3c 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1052
        -re ".* 394      12345678" { set x [expr $x+1]; exp_continue; }
 
1053
        -re ".* 394      1170" { set x [expr $x+1]; exp_continue; }
 
1054
        -re ".* 395 0a46 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1055
        -re ".* 395      12345678" { set x [expr $x+1]; exp_continue; }
 
1056
        -re ".* 395      1170" { set x [expr $x+1]; exp_continue; }
 
1057
        -re ".* 396 0a50 01046B08" { set x [expr $x+1]; exp_continue; }
 
1058
        -re ".* 396      12341170" { set x [expr $x+1]; exp_continue; }
 
1059
        -re ".* 397 0a58 01046B28" { set x [expr $x+1]; exp_continue; }
 
1060
        -re ".* 397      12345678" { set x [expr $x+1]; exp_continue; }
 
1061
        -re ".* 397      1170" { set x [expr $x+1]; exp_continue; }
 
1062
        -re ".* 398              " {
 
1063
            if [expr $x == 38] then {
 
1064
                pass "$testname: shlr.l #2, ..."
 
1065
            } else {
 
1066
                fail "$testname: shlr.l #2, ... ($x)"
 
1067
            }
 
1068
        }
 
1069
        default { fail "$testname: shlr.l #2, ... ($x)" }
 
1070
    }
 
1071
 
 
1072
    set x 0
 
1073
    expect {
 
1074
        -re ".* 399 0a62 11A1" { set x [expr $x+1]; exp_continue; }
 
1075
        -re ".* 400 0a64 7D1011A0" { set x [expr $x+1]; exp_continue; }
 
1076
        -re ".* 401 0a68 01776818" { set x [expr $x+1]; exp_continue; }
 
1077
        -re ".* 401      11A0" { set x [expr $x+1]; exp_continue; }
 
1078
        -re ".* 402 0a6e 01746C18" { set x [expr $x+1]; exp_continue; }
 
1079
        -re ".* 402      11A0" { set x [expr $x+1]; exp_continue; }
 
1080
        -re ".* 403 0a74 01776C18" { set x [expr $x+1]; exp_continue; }
 
1081
        -re ".* 403      11A0" { set x [expr $x+1]; exp_continue; }
 
1082
        -re ".* 404 0a7a 01756C18" { set x [expr $x+1]; exp_continue; }
 
1083
        -re ".* 404      11A0" { set x [expr $x+1]; exp_continue; }
 
1084
        -re ".* 405 0a80 01766C18" { set x [expr $x+1]; exp_continue; }
 
1085
        -re ".* 405      11A0" { set x [expr $x+1]; exp_continue; }
 
1086
        -re ".* 406 0a86 01746E18" { set x [expr $x+1]; exp_continue; }
 
1087
        -re ".* 406      123411A0" { set x [expr $x+1]; exp_continue; }
 
1088
        -re ".* 407 0a8e 78146A28" { set x [expr $x+1]; exp_continue; }
 
1089
        -re ".* 407      12345678" { set x [expr $x+1]; exp_continue; }
 
1090
        -re ".* 407      11A0" { set x [expr $x+1]; exp_continue; }
 
1091
        -re ".* 408 0a98 01756E28" { set x [expr $x+1]; exp_continue; }
 
1092
        -re ".* 408      123411A0" { set x [expr $x+1]; exp_continue; }
 
1093
        -re ".* 409 0aa0 01766E28" { set x [expr $x+1]; exp_continue; }
 
1094
        -re ".* 409      123411A0" { set x [expr $x+1]; exp_continue; }
 
1095
        -re ".* 410 0aa8 01776E28" { set x [expr $x+1]; exp_continue; }
 
1096
        -re ".* 410      123411A0" { set x [expr $x+1]; exp_continue; }
 
1097
        -re ".* 411 0ab0 78256A28" { set x [expr $x+1]; exp_continue; }
 
1098
        -re ".* 411      12345678" { set x [expr $x+1]; exp_continue; }
 
1099
        -re ".* 411      11A0" { set x [expr $x+1]; exp_continue; }
 
1100
        -re ".* 412 0aba 78266A28" { set x [expr $x+1]; exp_continue; }
 
1101
        -re ".* 412      12345678" { set x [expr $x+1]; exp_continue; }
 
1102
        -re ".* 412      11A0" { set x [expr $x+1]; exp_continue; }
 
1103
        -re ".* 413 0ac4 78276A28" { set x [expr $x+1]; exp_continue; }
 
1104
        -re ".* 413      12345678" { set x [expr $x+1]; exp_continue; }
 
1105
        -re ".* 413      11A0" { set x [expr $x+1]; exp_continue; }
 
1106
        -re ".* 414 0ace 7F1211A0" { set x [expr $x+1]; exp_continue; }
 
1107
        -re ".* 415 0ad2 6A181234" { set x [expr $x+1]; exp_continue; }
 
1108
        -re ".* 415      11A0" { set x [expr $x+1]; exp_continue; }
 
1109
        -re ".* 416 0ad8 6A381234" { set x [expr $x+1]; exp_continue; }
 
1110
        -re ".* 416      567811A0" { set x [expr $x+1]; exp_continue; }
 
1111
        -re ".* 417              " {
 
1112
            if [expr $x == 37] then {
 
1113
                pass "$testname: shlr.b #4, ..."
 
1114
            } else {
 
1115
                fail "$testname: shlr.b #4, ... ($x)"
 
1116
            }
 
1117
        }
 
1118
        default { fail "$testname: shlr.b #4, ... ($x)" }
 
1119
    }
 
1120
 
 
1121
    set x 0
 
1122
    expect {
 
1123
        -re ".* 418 0ae0 1121" { set x [expr $x+1]; exp_continue; }
 
1124
        -re ".* 419 0ae2 7D901120" { set x [expr $x+1]; exp_continue; }
 
1125
        -re ".* 420 0ae6 01576918" { set x [expr $x+1]; exp_continue; }
 
1126
        -re ".* 420      1120" { set x [expr $x+1]; exp_continue; }
 
1127
        -re ".* 421 0aec 01546D18" { set x [expr $x+1]; exp_continue; }
 
1128
        -re ".* 421      1120" { set x [expr $x+1]; exp_continue; }
 
1129
        -re ".* 422 0af2 01576D18" { set x [expr $x+1]; exp_continue; }
 
1130
        -re ".* 422      1120" { set x [expr $x+1]; exp_continue; }
 
1131
        -re ".* 423 0af8 01556D18" { set x [expr $x+1]; exp_continue; }
 
1132
        -re ".* 423      1120" { set x [expr $x+1]; exp_continue; }
 
1133
        -re ".* 424 0afe 01566D18" { set x [expr $x+1]; exp_continue; }
 
1134
        -re ".* 424      1120" { set x [expr $x+1]; exp_continue; }
 
1135
        -re ".* 425 0b04 01546F18" { set x [expr $x+1]; exp_continue; }
 
1136
        -re ".* 425      12341120" { set x [expr $x+1]; exp_continue; }
 
1137
        -re ".* 426 0b0c 78146B28" { set x [expr $x+1]; exp_continue; }
 
1138
        -re ".* 426      12345678" { set x [expr $x+1]; exp_continue; }
 
1139
        -re ".* 426      1120" { set x [expr $x+1]; exp_continue; }
 
1140
        -re ".* 427 0b16 01556F28" { set x [expr $x+1]; exp_continue; }
 
1141
        -re ".* 427      12341120" { set x [expr $x+1]; exp_continue; }
 
1142
        -re ".* 428 0b1e 01566F28" { set x [expr $x+1]; exp_continue; }
 
1143
        -re ".* 428      12341120" { set x [expr $x+1]; exp_continue; }
 
1144
        -re ".* 429 0b26 01576F28" { set x [expr $x+1]; exp_continue; }
 
1145
        -re ".* 429      12341120" { set x [expr $x+1]; exp_continue; }
 
1146
        -re ".* 430 0b2e 78256B28" { set x [expr $x+1]; exp_continue; }
 
1147
        -re ".* 430      12345678" { set x [expr $x+1]; exp_continue; }
 
1148
        -re ".* 430      1120" { set x [expr $x+1]; exp_continue; }
 
1149
        -re ".* 431 0b38 78266B28" { set x [expr $x+1]; exp_continue; }
 
1150
        -re ".* 431      12345678" { set x [expr $x+1]; exp_continue; }
 
1151
        -re ".* 431      1120" { set x [expr $x+1]; exp_continue; }
 
1152
        -re ".* 432 0b42 78276B28" { set x [expr $x+1]; exp_continue; }
 
1153
        -re ".* 432      12345678" { set x [expr $x+1]; exp_continue; }
 
1154
        -re ".* 432      1120" { set x [expr $x+1]; exp_continue; }
 
1155
        -re ".* 433 0b4c 6B181234" { set x [expr $x+1]; exp_continue; }
 
1156
        -re ".* 433      1120" { set x [expr $x+1]; exp_continue; }
 
1157
        -re ".* 434 0b52 6B381234" { set x [expr $x+1]; exp_continue; }
 
1158
        -re ".* 434      56781120" { set x [expr $x+1]; exp_continue; }
 
1159
        -re ".* 435              " {
 
1160
            if [expr $x == 36] then {
 
1161
                pass "$testname: shlr.w #4, ..."
 
1162
            } else {
 
1163
                fail "$testname: shlr.w #4, ... ($x)"
 
1164
            }
 
1165
        }
 
1166
        default { fail "$testname: shlr.w #4, ... ($x)" }
 
1167
    }
 
1168
 
 
1169
    set x 0
 
1170
    expect {
 
1171
        -re ".* 436 0b5a 1139" { set x [expr $x+1]; exp_continue; }
 
1172
        -re ".* 437 0b5c 01046918" { set x [expr $x+1]; exp_continue; }
 
1173
        -re ".* 437      1138" { set x [expr $x+1]; exp_continue; }
 
1174
        -re ".* 438 0b62 01076918" { set x [expr $x+1]; exp_continue; }
 
1175
        -re ".* 438      1138" { set x [expr $x+1]; exp_continue; }
 
1176
        -re ".* 439 0b68 01046D18" { set x [expr $x+1]; exp_continue; }
 
1177
        -re ".* 439      1138" { set x [expr $x+1]; exp_continue; }
 
1178
        -re ".* 440 0b6e 01076D18" { set x [expr $x+1]; exp_continue; }
 
1179
        -re ".* 440      1138" { set x [expr $x+1]; exp_continue; }
 
1180
        -re ".* 441 0b74 01056D18" { set x [expr $x+1]; exp_continue; }
 
1181
        -re ".* 441      1138" { set x [expr $x+1]; exp_continue; }
 
1182
        -re ".* 442 0b7a 01066D18" { set x [expr $x+1]; exp_continue; }
 
1183
        -re ".* 442      1138" { set x [expr $x+1]; exp_continue; }
 
1184
        -re ".* 443 0b80 01046F18" { set x [expr $x+1]; exp_continue; }
 
1185
        -re ".* 443      12341138" { set x [expr $x+1]; exp_continue; }
 
1186
        -re ".* 444 0b88 78946B28" { set x [expr $x+1]; exp_continue; }
 
1187
        -re ".* 444      12345678" { set x [expr $x+1]; exp_continue; }
 
1188
        -re ".* 444      1138" { set x [expr $x+1]; exp_continue; }
 
1189
        -re ".* 445 0b92 01056F28" { set x [expr $x+1]; exp_continue; }
 
1190
        -re ".* 445      12341138" { set x [expr $x+1]; exp_continue; }
 
1191
        -re ".* 446 0b9a 01066F28" { set x [expr $x+1]; exp_continue; }
 
1192
        -re ".* 446      12341138" { set x [expr $x+1]; exp_continue; }
 
1193
        -re ".* 447 0ba2 01076F28" { set x [expr $x+1]; exp_continue; }
 
1194
        -re ".* 447      12341138" { set x [expr $x+1]; exp_continue; }
 
1195
        -re ".* 448 0baa 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1196
        -re ".* 448      12345678" { set x [expr $x+1]; exp_continue; }
 
1197
        -re ".* 448      1138" { set x [expr $x+1]; exp_continue; }
 
1198
        -re ".* 449 0bb4 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1199
        -re ".* 449      12345678" { set x [expr $x+1]; exp_continue; }
 
1200
        -re ".* 449      1138" { set x [expr $x+1]; exp_continue; }
 
1201
        -re ".* 450 0bbe 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1202
        -re ".* 450      12345678" { set x [expr $x+1]; exp_continue; }
 
1203
        -re ".* 450      1138" { set x [expr $x+1]; exp_continue; }
 
1204
        -re ".* 451 0bc8 01046B08" { set x [expr $x+1]; exp_continue; }
 
1205
        -re ".* 451      12341138" { set x [expr $x+1]; exp_continue; }
 
1206
        -re ".* 452 0bd0 01046B28" { set x [expr $x+1]; exp_continue; }
 
1207
        -re ".* 452      12345678" { set x [expr $x+1]; exp_continue; }
 
1208
        -re ".* 452      1138" { set x [expr $x+1]; exp_continue; }
 
1209
        -re ".* 453              " {
 
1210
            if [expr $x == 38] then {
 
1211
                pass "$testname: shlr.l #4, ..."
 
1212
            } else {
 
1213
                fail "$testname: shlr.l #4, ... ($x)"
 
1214
            }
 
1215
        }
 
1216
        default { fail "$testname: shlr.l #4, ... ($x)" }
 
1217
    }
 
1218
 
 
1219
    set x 0
 
1220
    expect {
 
1221
        -re ".* 454 0bda 1161" { set x [expr $x+1]; exp_continue; }
 
1222
        -re ".* 455 0bdc 7D901160" { set x [expr $x+1]; exp_continue; }
 
1223
        -re ".* 456 0be0 01576918" { set x [expr $x+1]; exp_continue; }
 
1224
        -re ".* 456      1160" { set x [expr $x+1]; exp_continue; }
 
1225
        -re ".* 457 0be6 01546D18" { set x [expr $x+1]; exp_continue; }
 
1226
        -re ".* 457      1160" { set x [expr $x+1]; exp_continue; }
 
1227
        -re ".* 458 0bec 01576D18" { set x [expr $x+1]; exp_continue; }
 
1228
        -re ".* 458      1160" { set x [expr $x+1]; exp_continue; }
 
1229
        -re ".* 459 0bf2 01556D18" { set x [expr $x+1]; exp_continue; }
 
1230
        -re ".* 459      1160" { set x [expr $x+1]; exp_continue; }
 
1231
        -re ".* 460 0bf8 01566D18" { set x [expr $x+1]; exp_continue; }
 
1232
        -re ".* 460      1160" { set x [expr $x+1]; exp_continue; }
 
1233
        -re ".* 461 0bfe 01546F18" { set x [expr $x+1]; exp_continue; }
 
1234
        -re ".* 461      12341160" { set x [expr $x+1]; exp_continue; }
 
1235
        -re ".* 462 0c06 78146B28" { set x [expr $x+1]; exp_continue; }
 
1236
        -re ".* 462      12345678" { set x [expr $x+1]; exp_continue; }
 
1237
        -re ".* 462      1160" { set x [expr $x+1]; exp_continue; }
 
1238
        -re ".* 463 0c10 01556F28" { set x [expr $x+1]; exp_continue; }
 
1239
        -re ".* 463      12341160" { set x [expr $x+1]; exp_continue; }
 
1240
        -re ".* 464 0c18 01566F28" { set x [expr $x+1]; exp_continue; }
 
1241
        -re ".* 464      12341160" { set x [expr $x+1]; exp_continue; }
 
1242
        -re ".* 465 0c20 01576F28" { set x [expr $x+1]; exp_continue; }
 
1243
        -re ".* 465      12341160" { set x [expr $x+1]; exp_continue; }
 
1244
        -re ".* 466 0c28 78256B28" { set x [expr $x+1]; exp_continue; }
 
1245
        -re ".* 466      12345678" { set x [expr $x+1]; exp_continue; }
 
1246
        -re ".* 466      1160" { set x [expr $x+1]; exp_continue; }
 
1247
        -re ".* 467 0c32 78266B28" { set x [expr $x+1]; exp_continue; }
 
1248
        -re ".* 467      12345678" { set x [expr $x+1]; exp_continue; }
 
1249
        -re ".* 467      1160" { set x [expr $x+1]; exp_continue; }
 
1250
        -re ".* 468 0c3c 78276B28" { set x [expr $x+1]; exp_continue; }
 
1251
        -re ".* 468      12345678" { set x [expr $x+1]; exp_continue; }
 
1252
        -re ".* 468      1160" { set x [expr $x+1]; exp_continue; }
 
1253
        -re ".* 469 0c46 6B181234" { set x [expr $x+1]; exp_continue; }
 
1254
        -re ".* 469      1160" { set x [expr $x+1]; exp_continue; }
 
1255
        -re ".* 470 0c4c 6B381234" { set x [expr $x+1]; exp_continue; }
 
1256
        -re ".* 470      56781160" { set x [expr $x+1]; exp_continue; }
 
1257
        -re ".* 471              " {
 
1258
            if [expr $x == 36] then {
 
1259
                pass "$testname: shlr.w #8, ..."
 
1260
            } else {
 
1261
                fail "$testname: shlr.w #8, ... ($x)"
 
1262
            }
 
1263
        }
 
1264
        default { fail "$testname: shlr.w #8, ... ($x)" }
 
1265
    }
 
1266
 
 
1267
    set x 0
 
1268
    expect {
 
1269
        -re ".* 472 0c54 1179" { set x [expr $x+1]; exp_continue; }
 
1270
        -re ".* 473 0c56 01046918" { set x [expr $x+1]; exp_continue; }
 
1271
        -re ".* 473      1178" { set x [expr $x+1]; exp_continue; }
 
1272
        -re ".* 474 0c5c 01076918" { set x [expr $x+1]; exp_continue; }
 
1273
        -re ".* 474      1178" { set x [expr $x+1]; exp_continue; }
 
1274
        -re ".* 475 0c62 01046D18" { set x [expr $x+1]; exp_continue; }
 
1275
        -re ".* 475      1178" { set x [expr $x+1]; exp_continue; }
 
1276
        -re ".* 476 0c68 01076D18" { set x [expr $x+1]; exp_continue; }
 
1277
        -re ".* 476      1178" { set x [expr $x+1]; exp_continue; }
 
1278
        -re ".* 477 0c6e 01056D18" { set x [expr $x+1]; exp_continue; }
 
1279
        -re ".* 477      1178" { set x [expr $x+1]; exp_continue; }
 
1280
        -re ".* 478 0c74 01066D18" { set x [expr $x+1]; exp_continue; }
 
1281
        -re ".* 478      1178" { set x [expr $x+1]; exp_continue; }
 
1282
        -re ".* 479 0c7a 01046F18" { set x [expr $x+1]; exp_continue; }
 
1283
        -re ".* 479      12341178" { set x [expr $x+1]; exp_continue; }
 
1284
        -re ".* 480 0c82 78946B28" { set x [expr $x+1]; exp_continue; }
 
1285
        -re ".* 480      12345678" { set x [expr $x+1]; exp_continue; }
 
1286
        -re ".* 480      1178" { set x [expr $x+1]; exp_continue; }
 
1287
        -re ".* 481 0c8c 01056F28" { set x [expr $x+1]; exp_continue; }
 
1288
        -re ".* 481      12341178" { set x [expr $x+1]; exp_continue; }
 
1289
        -re ".* 482 0c94 01066F28" { set x [expr $x+1]; exp_continue; }
 
1290
        -re ".* 482      12341178" { set x [expr $x+1]; exp_continue; }
 
1291
        -re ".* 483 0c9c 01076F28" { set x [expr $x+1]; exp_continue; }
 
1292
        -re ".* 483      12341178" { set x [expr $x+1]; exp_continue; }
 
1293
        -re ".* 484 0ca4 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1294
        -re ".* 484      12345678" { set x [expr $x+1]; exp_continue; }
 
1295
        -re ".* 484      1178" { set x [expr $x+1]; exp_continue; }
 
1296
        -re ".* 485 0cae 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1297
        -re ".* 485      12345678" { set x [expr $x+1]; exp_continue; }
 
1298
        -re ".* 485      1178" { set x [expr $x+1]; exp_continue; }
 
1299
        -re ".* 486 0cb8 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1300
        -re ".* 486      12345678" { set x [expr $x+1]; exp_continue; }
 
1301
        -re ".* 486      1178" { set x [expr $x+1]; exp_continue; }
 
1302
        -re ".* 487 0cc2 01046B08" { set x [expr $x+1]; exp_continue; }
 
1303
        -re ".* 487      12341178" { set x [expr $x+1]; exp_continue; }
 
1304
        -re ".* 488 0cca 01046B28" { set x [expr $x+1]; exp_continue; }
 
1305
        -re ".* 488      12345678" { set x [expr $x+1]; exp_continue; }
 
1306
        -re ".* 488      1178" { set x [expr $x+1]; exp_continue; }
 
1307
        -re ".* 489              " {
 
1308
            if [expr $x == 38] then {
 
1309
                pass "$testname: shlr.l #8, ..."
 
1310
            } else {
 
1311
                fail "$testname: shlr.l #8, ... ($x)"
 
1312
            }
 
1313
        }
 
1314
        default { fail "$testname: shlr.l #8, ... ($x)" }
 
1315
    }
 
1316
 
 
1317
    set x 0
 
1318
    expect {
 
1319
        -re ".* 490 0cd4 11F9" { set x [expr $x+1]; exp_continue; }
 
1320
        -re ".* 491 0cd6 01046918" { set x [expr $x+1]; exp_continue; }
 
1321
        -re ".* 491      11F8" { set x [expr $x+1]; exp_continue; }
 
1322
        -re ".* 492 0cdc 01076918" { set x [expr $x+1]; exp_continue; }
 
1323
        -re ".* 492      11F8" { set x [expr $x+1]; exp_continue; }
 
1324
        -re ".* 493 0ce2 01046D18" { set x [expr $x+1]; exp_continue; }
 
1325
        -re ".* 493      11F8" { set x [expr $x+1]; exp_continue; }
 
1326
        -re ".* 494 0ce8 01076D18" { set x [expr $x+1]; exp_continue; }
 
1327
        -re ".* 494      11F8" { set x [expr $x+1]; exp_continue; }
 
1328
        -re ".* 495 0cee 01056D18" { set x [expr $x+1]; exp_continue; }
 
1329
        -re ".* 495      11F8" { set x [expr $x+1]; exp_continue; }
 
1330
        -re ".* 496 0cf4 01066D18" { set x [expr $x+1]; exp_continue; }
 
1331
        -re ".* 496      11F8" { set x [expr $x+1]; exp_continue; }
 
1332
        -re ".* 497 0cfa 01046F18" { set x [expr $x+1]; exp_continue; }
 
1333
        -re ".* 497      123411F8" { set x [expr $x+1]; exp_continue; }
 
1334
        -re ".* 498 0d02 78946B28" { set x [expr $x+1]; exp_continue; }
 
1335
        -re ".* 498      12345678" { set x [expr $x+1]; exp_continue; }
 
1336
        -re ".* 498      11F8" { set x [expr $x+1]; exp_continue; }
 
1337
        -re ".* 499 0d0c 01056F28" { set x [expr $x+1]; exp_continue; }
 
1338
        -re ".* 499      123411F8" { set x [expr $x+1]; exp_continue; }
 
1339
        -re ".* 500 0d14 01066F28" { set x [expr $x+1]; exp_continue; }
 
1340
        -re ".* 500      123411F8" { set x [expr $x+1]; exp_continue; }
 
1341
        -re ".* 501 0d1c 01076F28" { set x [expr $x+1]; exp_continue; }
 
1342
        -re ".* 501      123411F8" { set x [expr $x+1]; exp_continue; }
 
1343
        -re ".* 502 0d24 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1344
        -re ".* 502      12345678" { set x [expr $x+1]; exp_continue; }
 
1345
        -re ".* 502      11F8" { set x [expr $x+1]; exp_continue; }
 
1346
        -re ".* 503 0d2e 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1347
        -re ".* 503      12345678" { set x [expr $x+1]; exp_continue; }
 
1348
        -re ".* 503      11F8" { set x [expr $x+1]; exp_continue; }
 
1349
        -re ".* 504 0d38 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1350
        -re ".* 504      12345678" { set x [expr $x+1]; exp_continue; }
 
1351
        -re ".* 504      11F8" { set x [expr $x+1]; exp_continue; }
 
1352
        -re ".* 505 0d42 01046B08" { set x [expr $x+1]; exp_continue; }
 
1353
        -re ".* 505      123411F8" { set x [expr $x+1]; exp_continue; }
 
1354
        -re ".* 506 0d4a 01046B28" { set x [expr $x+1]; exp_continue; }
 
1355
        -re ".* 506      12345678" { set x [expr $x+1]; exp_continue; }
 
1356
        -re ".* 506      11F8" { set x [expr $x+1]; exp_continue; }
 
1357
        -re ".* 507              " {
 
1358
            if [expr $x == 38] then {
 
1359
                pass "$testname: shlr.l #16, ..."
 
1360
            } else {
 
1361
                fail "$testname: shlr.l #16, ... ($x)"
 
1362
            }
 
1363
        }
 
1364
        default { fail "$testname: shlr.l #16, ... ($x)" }
 
1365
    }
 
1366
 
 
1367
    set x 0
 
1368
    expect {
 
1369
        -re ".* 508 0d54 03871101" { set x [expr $x+1]; exp_continue; }
 
1370
        -re ".* 509 0d58 038F1111" { set x [expr $x+1]; exp_continue; }
 
1371
        -re ".* 510 0d5c 039F1131" { set x [expr $x+1]; exp_continue; }
 
1372
        -re ".* 511              " {
 
1373
            if [expr $x == 3] then {
 
1374
                pass "$testname: shlr.? #imm:5, <reg>"
 
1375
            } else {
 
1376
                fail "$testname: shlr.? #imm:5, <reg> ($x)"
 
1377
            }
 
1378
        }
 
1379
        default { fail "$testname: shlr.? #imm:5, <reg> ($x)" }
 
1380
    }
 
1381
 
 
1382
    set x 0
 
1383
    expect {
 
1384
        -re ".* 512 0d60 78381101" { set x [expr $x+1]; exp_continue; }
 
1385
        -re ".* 513 0d64 78381111" { set x [expr $x+1]; exp_continue; }
 
1386
        -re ".* 514 0d68 78381131" { set x [expr $x+1]; exp_continue; }
 
1387
        -re ".* 515              " {
 
1388
            if [expr $x == 3] then {
 
1389
                pass "$testname: shlr.? r3h, <reg>"
 
1390
            } else {
 
1391
                fail "$testname: shlr.? r3h, <reg> ($x)"
 
1392
            }
 
1393
        }
 
1394
        default { fail "$testname: shlr.? r3h, <reg> ($x)" }
 
1395
    }
 
1396
 
 
1397
    set x 0
 
1398
    expect {
 
1399
        -re ".* 516 0d6c 1081" { set x [expr $x+1]; exp_continue; }
 
1400
        -re ".* 517 0d6e 7D101080" { set x [expr $x+1]; exp_continue; }
 
1401
        -re ".* 518 0d72 01776818" { set x [expr $x+1]; exp_continue; }
 
1402
        -re ".* 518      1080" { set x [expr $x+1]; exp_continue; }
 
1403
        -re ".* 519 0d78 01746C18" { set x [expr $x+1]; exp_continue; }
 
1404
        -re ".* 519      1080" { set x [expr $x+1]; exp_continue; }
 
1405
        -re ".* 520 0d7e 01776C18" { set x [expr $x+1]; exp_continue; }
 
1406
        -re ".* 520      1080" { set x [expr $x+1]; exp_continue; }
 
1407
        -re ".* 521 0d84 01756C18" { set x [expr $x+1]; exp_continue; }
 
1408
        -re ".* 521      1080" { set x [expr $x+1]; exp_continue; }
 
1409
        -re ".* 522 0d8a 01766C18" { set x [expr $x+1]; exp_continue; }
 
1410
        -re ".* 522      1080" { set x [expr $x+1]; exp_continue; }
 
1411
        -re ".* 523 0d90 01746E18" { set x [expr $x+1]; exp_continue; }
 
1412
        -re ".* 523      12341080" { set x [expr $x+1]; exp_continue; }
 
1413
        -re ".* 524 0d98 78146A28" { set x [expr $x+1]; exp_continue; }
 
1414
        -re ".* 524      12345678" { set x [expr $x+1]; exp_continue; }
 
1415
        -re ".* 524      1080" { set x [expr $x+1]; exp_continue; }
 
1416
        -re ".* 525 0da2 01756E28" { set x [expr $x+1]; exp_continue; }
 
1417
        -re ".* 525      12341080" { set x [expr $x+1]; exp_continue; }
 
1418
        -re ".* 526 0daa 01766E28" { set x [expr $x+1]; exp_continue; }
 
1419
        -re ".* 526      12341080" { set x [expr $x+1]; exp_continue; }
 
1420
        -re ".* 527 0db2 01776E28" { set x [expr $x+1]; exp_continue; }
 
1421
        -re ".* 527      12341080" { set x [expr $x+1]; exp_continue; }
 
1422
        -re ".* 528 0dba 78256A28" { set x [expr $x+1]; exp_continue; }
 
1423
        -re ".* 528      12345678" { set x [expr $x+1]; exp_continue; }
 
1424
        -re ".* 528      1080" { set x [expr $x+1]; exp_continue; }
 
1425
        -re ".* 529 0dc4 78266A28" { set x [expr $x+1]; exp_continue; }
 
1426
        -re ".* 529      12345678" { set x [expr $x+1]; exp_continue; }
 
1427
        -re ".* 529      1080" { set x [expr $x+1]; exp_continue; }
 
1428
        -re ".* 530 0dce 78276A28" { set x [expr $x+1]; exp_continue; }
 
1429
        -re ".* 530      12345678" { set x [expr $x+1]; exp_continue; }
 
1430
        -re ".* 530      1080" { set x [expr $x+1]; exp_continue; }
 
1431
        -re ".* 531 0dd8 7F121080" { set x [expr $x+1]; exp_continue; }
 
1432
        -re ".* 532 0ddc 6A181234" { set x [expr $x+1]; exp_continue; }
 
1433
        -re ".* 532      1080" { set x [expr $x+1]; exp_continue; }
 
1434
        -re ".* 533 0de2 6A381234" { set x [expr $x+1]; exp_continue; }
 
1435
        -re ".* 533      56781080" { set x [expr $x+1]; exp_continue; }
 
1436
        -re ".* 534              " {
 
1437
            if [expr $x == 37] then {
 
1438
                pass "$testname: shal.b ..."
 
1439
            } else {
 
1440
                fail "$testname: shal.b ... ($x)"
 
1441
            }
 
1442
        }
 
1443
        default { fail "$testname: shal.b ... ($x)" }
 
1444
    }
 
1445
 
 
1446
    set x 0
 
1447
    expect {
 
1448
        -re ".* 535 0dea 1091" { set x [expr $x+1]; exp_continue; }
 
1449
        -re ".* 536 0dec 7D901090" { set x [expr $x+1]; exp_continue; }
 
1450
        -re ".* 537 0df0 01576918" { set x [expr $x+1]; exp_continue; }
 
1451
        -re ".* 537      1090" { set x [expr $x+1]; exp_continue; }
 
1452
        -re ".* 538 0df6 01546D18" { set x [expr $x+1]; exp_continue; }
 
1453
        -re ".* 538      1090" { set x [expr $x+1]; exp_continue; }
 
1454
        -re ".* 539 0dfc 01576D18" { set x [expr $x+1]; exp_continue; }
 
1455
        -re ".* 539      1090" { set x [expr $x+1]; exp_continue; }
 
1456
        -re ".* 540 0e02 01556D18" { set x [expr $x+1]; exp_continue; }
 
1457
        -re ".* 540      1090" { set x [expr $x+1]; exp_continue; }
 
1458
        -re ".* 541 0e08 01566D18" { set x [expr $x+1]; exp_continue; }
 
1459
        -re ".* 541      1090" { set x [expr $x+1]; exp_continue; }
 
1460
        -re ".* 542 0e0e 01546F18" { set x [expr $x+1]; exp_continue; }
 
1461
        -re ".* 542      12341090" { set x [expr $x+1]; exp_continue; }
 
1462
        -re ".* 543 0e16 78146B28" { set x [expr $x+1]; exp_continue; }
 
1463
        -re ".* 543      12345678" { set x [expr $x+1]; exp_continue; }
 
1464
        -re ".* 543      1090" { set x [expr $x+1]; exp_continue; }
 
1465
        -re ".* 544 0e20 01556F28" { set x [expr $x+1]; exp_continue; }
 
1466
        -re ".* 544      12341090" { set x [expr $x+1]; exp_continue; }
 
1467
        -re ".* 545 0e28 01566F28" { set x [expr $x+1]; exp_continue; }
 
1468
        -re ".* 545      12341090" { set x [expr $x+1]; exp_continue; }
 
1469
        -re ".* 546 0e30 01576F28" { set x [expr $x+1]; exp_continue; }
 
1470
        -re ".* 546      12341090" { set x [expr $x+1]; exp_continue; }
 
1471
        -re ".* 547 0e38 78256B28" { set x [expr $x+1]; exp_continue; }
 
1472
        -re ".* 547      12345678" { set x [expr $x+1]; exp_continue; }
 
1473
        -re ".* 547      1090" { set x [expr $x+1]; exp_continue; }
 
1474
        -re ".* 548 0e42 78266B28" { set x [expr $x+1]; exp_continue; }
 
1475
        -re ".* 548      12345678" { set x [expr $x+1]; exp_continue; }
 
1476
        -re ".* 548      1090" { set x [expr $x+1]; exp_continue; }
 
1477
        -re ".* 549 0e4c 78276B28" { set x [expr $x+1]; exp_continue; }
 
1478
        -re ".* 549      12345678" { set x [expr $x+1]; exp_continue; }
 
1479
        -re ".* 549      1090" { set x [expr $x+1]; exp_continue; }
 
1480
        -re ".* 550 0e56 6B181234" { set x [expr $x+1]; exp_continue; }
 
1481
        -re ".* 550      1090" { set x [expr $x+1]; exp_continue; }
 
1482
        -re ".* 551 0e5c 6B381234" { set x [expr $x+1]; exp_continue; }
 
1483
        -re ".* 551      56781090" { set x [expr $x+1]; exp_continue; }
 
1484
        -re ".* 552              " {
 
1485
            if [expr $x == 36] then {
 
1486
                pass "$testname: shal.w ..."
 
1487
            } else {
 
1488
                fail "$testname: shal.w ... ($x)"
 
1489
            }
 
1490
        }
 
1491
        default { fail "$testname: shal.w ... ($x)" }
 
1492
    }
 
1493
 
 
1494
    set x 0
 
1495
    expect {
 
1496
        -re ".* 553 0e64 10B1" { set x [expr $x+1]; exp_continue; }
 
1497
        -re ".* 554 0e66 01046918" { set x [expr $x+1]; exp_continue; }
 
1498
        -re ".* 554      10B0" { set x [expr $x+1]; exp_continue; }
 
1499
        -re ".* 555 0e6c 01076918" { set x [expr $x+1]; exp_continue; }
 
1500
        -re ".* 555      10B0" { set x [expr $x+1]; exp_continue; }
 
1501
        -re ".* 556 0e72 01046D18" { set x [expr $x+1]; exp_continue; }
 
1502
        -re ".* 556      10B0" { set x [expr $x+1]; exp_continue; }
 
1503
        -re ".* 557 0e78 01076D18" { set x [expr $x+1]; exp_continue; }
 
1504
        -re ".* 557      10B0" { set x [expr $x+1]; exp_continue; }
 
1505
        -re ".* 558 0e7e 01056D18" { set x [expr $x+1]; exp_continue; }
 
1506
        -re ".* 558      10B0" { set x [expr $x+1]; exp_continue; }
 
1507
        -re ".* 559 0e84 01066D18" { set x [expr $x+1]; exp_continue; }
 
1508
        -re ".* 559      10B0" { set x [expr $x+1]; exp_continue; }
 
1509
        -re ".* 560 0e8a 01046F18" { set x [expr $x+1]; exp_continue; }
 
1510
        -re ".* 560      123410B0" { set x [expr $x+1]; exp_continue; }
 
1511
        -re ".* 561 0e92 78946B28" { set x [expr $x+1]; exp_continue; }
 
1512
        -re ".* 561      12345678" { set x [expr $x+1]; exp_continue; }
 
1513
        -re ".* 561      10B0" { set x [expr $x+1]; exp_continue; }
 
1514
        -re ".* 562 0e9c 01056F28" { set x [expr $x+1]; exp_continue; }
 
1515
        -re ".* 562      123410B0" { set x [expr $x+1]; exp_continue; }
 
1516
        -re ".* 563 0ea4 01066F28" { set x [expr $x+1]; exp_continue; }
 
1517
        -re ".* 563      123410B0" { set x [expr $x+1]; exp_continue; }
 
1518
        -re ".* 564 0eac 01076F28" { set x [expr $x+1]; exp_continue; }
 
1519
        -re ".* 564      123410B0" { set x [expr $x+1]; exp_continue; }
 
1520
        -re ".* 565 0eb4 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1521
        -re ".* 565      12345678" { set x [expr $x+1]; exp_continue; }
 
1522
        -re ".* 565      10B0" { set x [expr $x+1]; exp_continue; }
 
1523
        -re ".* 566 0ebe 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1524
        -re ".* 566      12345678" { set x [expr $x+1]; exp_continue; }
 
1525
        -re ".* 566      10B0" { set x [expr $x+1]; exp_continue; }
 
1526
        -re ".* 567 0ec8 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1527
        -re ".* 567      12345678" { set x [expr $x+1]; exp_continue; }
 
1528
        -re ".* 567      10B0" { set x [expr $x+1]; exp_continue; }
 
1529
        -re ".* 568 0ed2 01046B08" { set x [expr $x+1]; exp_continue; }
 
1530
        -re ".* 568      123410B0" { set x [expr $x+1]; exp_continue; }
 
1531
        -re ".* 569 0eda 01046B28" { set x [expr $x+1]; exp_continue; }
 
1532
        -re ".* 569      12345678" { set x [expr $x+1]; exp_continue; }
 
1533
        -re ".* 569      10B0" { set x [expr $x+1]; exp_continue; }
 
1534
        -re ".* 570              " {
 
1535
            if [expr $x == 38] then {
 
1536
                pass "$testname: shal.l ..."
 
1537
            } else {
 
1538
                fail "$testname: shal.l ... ($x)"
 
1539
            }
 
1540
        }
 
1541
        default { fail "$testname: shal.l ... ($x)" }
 
1542
    }
 
1543
 
 
1544
    set x 0
 
1545
    expect {
 
1546
        -re ".* 571 0ee4 10C1" { set x [expr $x+1]; exp_continue; }
 
1547
        -re ".* 572 0ee6 7D1010C0" { set x [expr $x+1]; exp_continue; }
 
1548
        -re ".* 573 0eea 01776818" { set x [expr $x+1]; exp_continue; }
 
1549
        -re ".* 573      10C0" { set x [expr $x+1]; exp_continue; }
 
1550
        -re ".* 574 0ef0 01746C18" { set x [expr $x+1]; exp_continue; }
 
1551
        -re ".* 574      10C0" { set x [expr $x+1]; exp_continue; }
 
1552
        -re ".* 575 0ef6 01776C18" { set x [expr $x+1]; exp_continue; }
 
1553
        -re ".* 575      10C0" { set x [expr $x+1]; exp_continue; }
 
1554
        -re ".* 576 0efc 01756C18" { set x [expr $x+1]; exp_continue; }
 
1555
        -re ".* 576      10C0" { set x [expr $x+1]; exp_continue; }
 
1556
        -re ".* 577 0f02 01766C18" { set x [expr $x+1]; exp_continue; }
 
1557
        -re ".* 577      10C0" { set x [expr $x+1]; exp_continue; }
 
1558
        -re ".* 578 0f08 01746E18" { set x [expr $x+1]; exp_continue; }
 
1559
        -re ".* 578      123410C0" { set x [expr $x+1]; exp_continue; }
 
1560
        -re ".* 579 0f10 78146A28" { set x [expr $x+1]; exp_continue; }
 
1561
        -re ".* 579      12345678" { set x [expr $x+1]; exp_continue; }
 
1562
        -re ".* 579      10C0" { set x [expr $x+1]; exp_continue; }
 
1563
        -re ".* 580 0f1a 01756E28" { set x [expr $x+1]; exp_continue; }
 
1564
        -re ".* 580      123410C0" { set x [expr $x+1]; exp_continue; }
 
1565
        -re ".* 581 0f22 01766E28" { set x [expr $x+1]; exp_continue; }
 
1566
        -re ".* 581      123410C0" { set x [expr $x+1]; exp_continue; }
 
1567
        -re ".* 582 0f2a 01776E28" { set x [expr $x+1]; exp_continue; }
 
1568
        -re ".* 582      123410C0" { set x [expr $x+1]; exp_continue; }
 
1569
        -re ".* 583 0f32 78256A28" { set x [expr $x+1]; exp_continue; }
 
1570
        -re ".* 583      12345678" { set x [expr $x+1]; exp_continue; }
 
1571
        -re ".* 583      10C0" { set x [expr $x+1]; exp_continue; }
 
1572
        -re ".* 584 0f3c 78266A28" { set x [expr $x+1]; exp_continue; }
 
1573
        -re ".* 584      12345678" { set x [expr $x+1]; exp_continue; }
 
1574
        -re ".* 584      10C0" { set x [expr $x+1]; exp_continue; }
 
1575
        -re ".* 585 0f46 78276A28" { set x [expr $x+1]; exp_continue; }
 
1576
        -re ".* 585      12345678" { set x [expr $x+1]; exp_continue; }
 
1577
        -re ".* 585      10C0" { set x [expr $x+1]; exp_continue; }
 
1578
        -re ".* 586 0f50 7F1210C0" { set x [expr $x+1]; exp_continue; }
 
1579
        -re ".* 587 0f54 6A181234" { set x [expr $x+1]; exp_continue; }
 
1580
        -re ".* 587      10C0" { set x [expr $x+1]; exp_continue; }
 
1581
        -re ".* 588 0f5a 6A381234" { set x [expr $x+1]; exp_continue; }
 
1582
        -re ".* 588      567810C0" { set x [expr $x+1]; exp_continue; }
 
1583
        -re ".* 589              " {
 
1584
            if [expr $x == 37] then {
 
1585
                pass "$testname: shal.b #2, ..."
 
1586
            } else {
 
1587
                fail "$testname: shal.b #2, ... ($x)"
 
1588
            }
 
1589
        }
 
1590
        default { fail "$testname: shal.b #2, ... ($x)" }
 
1591
    }
 
1592
 
 
1593
    set x 0
 
1594
    expect {
 
1595
        -re ".* 590 0f62 10D1" { set x [expr $x+1]; exp_continue; }
 
1596
        -re ".* 591 0f64 7D9010D0" { set x [expr $x+1]; exp_continue; }
 
1597
        -re ".* 592 0f68 01576918" { set x [expr $x+1]; exp_continue; }
 
1598
        -re ".* 592      10D0" { set x [expr $x+1]; exp_continue; }
 
1599
        -re ".* 593 0f6e 01546D18" { set x [expr $x+1]; exp_continue; }
 
1600
        -re ".* 593      10D0" { set x [expr $x+1]; exp_continue; }
 
1601
        -re ".* 594 0f74 01576D18" { set x [expr $x+1]; exp_continue; }
 
1602
        -re ".* 594      10D0" { set x [expr $x+1]; exp_continue; }
 
1603
        -re ".* 595 0f7a 01556D18" { set x [expr $x+1]; exp_continue; }
 
1604
        -re ".* 595      10D0" { set x [expr $x+1]; exp_continue; }
 
1605
        -re ".* 596 0f80 01566D18" { set x [expr $x+1]; exp_continue; }
 
1606
        -re ".* 596      10D0" { set x [expr $x+1]; exp_continue; }
 
1607
        -re ".* 597 0f86 01546F18" { set x [expr $x+1]; exp_continue; }
 
1608
        -re ".* 597      123410D0" { set x [expr $x+1]; exp_continue; }
 
1609
        -re ".* 598 0f8e 78146B28" { set x [expr $x+1]; exp_continue; }
 
1610
        -re ".* 598      12345678" { set x [expr $x+1]; exp_continue; }
 
1611
        -re ".* 598      10D0" { set x [expr $x+1]; exp_continue; }
 
1612
        -re ".* 599 0f98 01556F28" { set x [expr $x+1]; exp_continue; }
 
1613
        -re ".* 599      123410D0" { set x [expr $x+1]; exp_continue; }
 
1614
        -re ".* 600 0fa0 01566F28" { set x [expr $x+1]; exp_continue; }
 
1615
        -re ".* 600      123410D0" { set x [expr $x+1]; exp_continue; }
 
1616
        -re ".* 601 0fa8 01576F28" { set x [expr $x+1]; exp_continue; }
 
1617
        -re ".* 601      123410D0" { set x [expr $x+1]; exp_continue; }
 
1618
        -re ".* 602 0fb0 78256B28" { set x [expr $x+1]; exp_continue; }
 
1619
        -re ".* 602      12345678" { set x [expr $x+1]; exp_continue; }
 
1620
        -re ".* 602      10D0" { set x [expr $x+1]; exp_continue; }
 
1621
        -re ".* 603 0fba 78266B28" { set x [expr $x+1]; exp_continue; }
 
1622
        -re ".* 603      12345678" { set x [expr $x+1]; exp_continue; }
 
1623
        -re ".* 603      10D0" { set x [expr $x+1]; exp_continue; }
 
1624
        -re ".* 604 0fc4 78276B28" { set x [expr $x+1]; exp_continue; }
 
1625
        -re ".* 604      12345678" { set x [expr $x+1]; exp_continue; }
 
1626
        -re ".* 604      10D0" { set x [expr $x+1]; exp_continue; }
 
1627
        -re ".* 605 0fce 6B181234" { set x [expr $x+1]; exp_continue; }
 
1628
        -re ".* 605      10D0" { set x [expr $x+1]; exp_continue; }
 
1629
        -re ".* 606 0fd4 6B381234" { set x [expr $x+1]; exp_continue; }
 
1630
        -re ".* 606      567810D0" { set x [expr $x+1]; exp_continue; }
 
1631
        -re ".* 607              " {
 
1632
            if [expr $x == 36] then {
 
1633
                pass "$testname: shal.w #2, ..."
 
1634
            } else {
 
1635
                fail "$testname: shal.w #2, ... ($x)"
 
1636
            }
 
1637
        }
 
1638
        default { fail "$testname: shal.w #2, ... ($x)" }
 
1639
    }
 
1640
 
 
1641
    set x 0
 
1642
    expect {
 
1643
        -re ".* 608 0fdc 10F1" { set x [expr $x+1]; exp_continue; }
 
1644
        -re ".* 609 0fde 01046918" { set x [expr $x+1]; exp_continue; }
 
1645
        -re ".* 609      10F0" { set x [expr $x+1]; exp_continue; }
 
1646
        -re ".* 610 0fe4 01076918" { set x [expr $x+1]; exp_continue; }
 
1647
        -re ".* 610      10F0" { set x [expr $x+1]; exp_continue; }
 
1648
        -re ".* 611 0fea 01046D18" { set x [expr $x+1]; exp_continue; }
 
1649
        -re ".* 611      10F0" { set x [expr $x+1]; exp_continue; }
 
1650
        -re ".* 612 0ff0 01076D18" { set x [expr $x+1]; exp_continue; }
 
1651
        -re ".* 612      10F0" { set x [expr $x+1]; exp_continue; }
 
1652
        -re ".* 613 0ff6 01056D18" { set x [expr $x+1]; exp_continue; }
 
1653
        -re ".* 613      10F0" { set x [expr $x+1]; exp_continue; }
 
1654
        -re ".* 614 0ffc 01066D18" { set x [expr $x+1]; exp_continue; }
 
1655
        -re ".* 614      10F0" { set x [expr $x+1]; exp_continue; }
 
1656
        -re ".* 615 1002 01046F18" { set x [expr $x+1]; exp_continue; }
 
1657
        -re ".* 615      123410F0" { set x [expr $x+1]; exp_continue; }
 
1658
        -re ".* 616 100a 78946B28" { set x [expr $x+1]; exp_continue; }
 
1659
        -re ".* 616      12345678" { set x [expr $x+1]; exp_continue; }
 
1660
        -re ".* 616      10F0" { set x [expr $x+1]; exp_continue; }
 
1661
        -re ".* 617 1014 01056F28" { set x [expr $x+1]; exp_continue; }
 
1662
        -re ".* 617      123410F0" { set x [expr $x+1]; exp_continue; }
 
1663
        -re ".* 618 101c 01066F28" { set x [expr $x+1]; exp_continue; }
 
1664
        -re ".* 618      123410F0" { set x [expr $x+1]; exp_continue; }
 
1665
        -re ".* 619 1024 01076F28" { set x [expr $x+1]; exp_continue; }
 
1666
        -re ".* 619      123410F0" { set x [expr $x+1]; exp_continue; }
 
1667
        -re ".* 620 102c 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1668
        -re ".* 620      12345678" { set x [expr $x+1]; exp_continue; }
 
1669
        -re ".* 620      10F0" { set x [expr $x+1]; exp_continue; }
 
1670
        -re ".* 621 1036 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1671
        -re ".* 621      12345678" { set x [expr $x+1]; exp_continue; }
 
1672
        -re ".* 621      10F0" { set x [expr $x+1]; exp_continue; }
 
1673
        -re ".* 622 1040 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1674
        -re ".* 622      12345678" { set x [expr $x+1]; exp_continue; }
 
1675
        -re ".* 622      10F0" { set x [expr $x+1]; exp_continue; }
 
1676
        -re ".* 623 104a 01046B08" { set x [expr $x+1]; exp_continue; }
 
1677
        -re ".* 623      123410F0" { set x [expr $x+1]; exp_continue; }
 
1678
        -re ".* 624 1052 01046B28" { set x [expr $x+1]; exp_continue; }
 
1679
        -re ".* 624      12345678" { set x [expr $x+1]; exp_continue; }
 
1680
        -re ".* 624      10F0" { set x [expr $x+1]; exp_continue; }
 
1681
        -re ".* 625              " {
 
1682
            if [expr $x == 38] then {
 
1683
                pass "$testname: shal.l #2, ..."
 
1684
            } else {
 
1685
                fail "$testname: shal.l #2, ... ($x)"
 
1686
            }
 
1687
        }
 
1688
        default { fail "$testname: shal.l #2, ... ($x)" }
 
1689
    }
 
1690
 
 
1691
    set x 0
 
1692
    expect {
 
1693
        -re ".* 626 105c 1181" { set x [expr $x+1]; exp_continue; }
 
1694
        -re ".* 627 105e 7D101180" { set x [expr $x+1]; exp_continue; }
 
1695
        -re ".* 628 1062 01776818" { set x [expr $x+1]; exp_continue; }
 
1696
        -re ".* 628      1180" { set x [expr $x+1]; exp_continue; }
 
1697
        -re ".* 629 1068 01746C18" { set x [expr $x+1]; exp_continue; }
 
1698
        -re ".* 629      1180" { set x [expr $x+1]; exp_continue; }
 
1699
        -re ".* 630 106e 01776C18" { set x [expr $x+1]; exp_continue; }
 
1700
        -re ".* 630      1180" { set x [expr $x+1]; exp_continue; }
 
1701
        -re ".* 631 1074 01756C18" { set x [expr $x+1]; exp_continue; }
 
1702
        -re ".* 631      1180" { set x [expr $x+1]; exp_continue; }
 
1703
        -re ".* 632 107a 01766C18" { set x [expr $x+1]; exp_continue; }
 
1704
        -re ".* 632      1180" { set x [expr $x+1]; exp_continue; }
 
1705
        -re ".* 633 1080 01746E18" { set x [expr $x+1]; exp_continue; }
 
1706
        -re ".* 633      12341180" { set x [expr $x+1]; exp_continue; }
 
1707
        -re ".* 634 1088 78146A28" { set x [expr $x+1]; exp_continue; }
 
1708
        -re ".* 634      12345678" { set x [expr $x+1]; exp_continue; }
 
1709
        -re ".* 634      1180" { set x [expr $x+1]; exp_continue; }
 
1710
        -re ".* 635 1092 01756E28" { set x [expr $x+1]; exp_continue; }
 
1711
        -re ".* 635      12341180" { set x [expr $x+1]; exp_continue; }
 
1712
        -re ".* 636 109a 01766E28" { set x [expr $x+1]; exp_continue; }
 
1713
        -re ".* 636      12341180" { set x [expr $x+1]; exp_continue; }
 
1714
        -re ".* 637 10a2 01776E28" { set x [expr $x+1]; exp_continue; }
 
1715
        -re ".* 637      12341180" { set x [expr $x+1]; exp_continue; }
 
1716
        -re ".* 638 10aa 78256A28" { set x [expr $x+1]; exp_continue; }
 
1717
        -re ".* 638      12345678" { set x [expr $x+1]; exp_continue; }
 
1718
        -re ".* 638      1180" { set x [expr $x+1]; exp_continue; }
 
1719
        -re ".* 639 10b4 78266A28" { set x [expr $x+1]; exp_continue; }
 
1720
        -re ".* 639      12345678" { set x [expr $x+1]; exp_continue; }
 
1721
        -re ".* 639      1180" { set x [expr $x+1]; exp_continue; }
 
1722
        -re ".* 640 10be 78276A28" { set x [expr $x+1]; exp_continue; }
 
1723
        -re ".* 640      12345678" { set x [expr $x+1]; exp_continue; }
 
1724
        -re ".* 640      1180" { set x [expr $x+1]; exp_continue; }
 
1725
        -re ".* 641 10c8 7F121180" { set x [expr $x+1]; exp_continue; }
 
1726
        -re ".* 642 10cc 6A181234" { set x [expr $x+1]; exp_continue; }
 
1727
        -re ".* 642      1180" { set x [expr $x+1]; exp_continue; }
 
1728
        -re ".* 643 10d2 6A381234" { set x [expr $x+1]; exp_continue; }
 
1729
        -re ".* 643      56781180" { set x [expr $x+1]; exp_continue; }
 
1730
        -re ".* 644              " {
 
1731
            if [expr $x == 37] then {
 
1732
                pass "$testname: shar.b ..."
 
1733
            } else {
 
1734
                fail "$testname: shar.b ... ($x)"
 
1735
            }
 
1736
        }
 
1737
        default { fail "$testname: shar.b ... ($x)" }
 
1738
    }
 
1739
 
 
1740
    set x 0
 
1741
    expect {
 
1742
        -re ".* 645 10da 1191" { set x [expr $x+1]; exp_continue; }
 
1743
        -re ".* 646 10dc 7D901190" { set x [expr $x+1]; exp_continue; }
 
1744
        -re ".* 647 10e0 01576918" { set x [expr $x+1]; exp_continue; }
 
1745
        -re ".* 647      1190" { set x [expr $x+1]; exp_continue; }
 
1746
        -re ".* 648 10e6 01546D18" { set x [expr $x+1]; exp_continue; }
 
1747
        -re ".* 648      1190" { set x [expr $x+1]; exp_continue; }
 
1748
        -re ".* 649 10ec 01576D18" { set x [expr $x+1]; exp_continue; }
 
1749
        -re ".* 649      1190" { set x [expr $x+1]; exp_continue; }
 
1750
        -re ".* 650 10f2 01556D18" { set x [expr $x+1]; exp_continue; }
 
1751
        -re ".* 650      1190" { set x [expr $x+1]; exp_continue; }
 
1752
        -re ".* 651 10f8 01566D18" { set x [expr $x+1]; exp_continue; }
 
1753
        -re ".* 651      1190" { set x [expr $x+1]; exp_continue; }
 
1754
        -re ".* 652 10fe 01546F18" { set x [expr $x+1]; exp_continue; }
 
1755
        -re ".* 652      12341190" { set x [expr $x+1]; exp_continue; }
 
1756
        -re ".* 653 1106 78146B28" { set x [expr $x+1]; exp_continue; }
 
1757
        -re ".* 653      12345678" { set x [expr $x+1]; exp_continue; }
 
1758
        -re ".* 653      1190" { set x [expr $x+1]; exp_continue; }
 
1759
        -re ".* 654 1110 01556F28" { set x [expr $x+1]; exp_continue; }
 
1760
        -re ".* 654      12341190" { set x [expr $x+1]; exp_continue; }
 
1761
        -re ".* 655 1118 01566F28" { set x [expr $x+1]; exp_continue; }
 
1762
        -re ".* 655      12341190" { set x [expr $x+1]; exp_continue; }
 
1763
        -re ".* 656 1120 01576F28" { set x [expr $x+1]; exp_continue; }
 
1764
        -re ".* 656      12341190" { set x [expr $x+1]; exp_continue; }
 
1765
        -re ".* 657 1128 78256B28" { set x [expr $x+1]; exp_continue; }
 
1766
        -re ".* 657      12345678" { set x [expr $x+1]; exp_continue; }
 
1767
        -re ".* 657      1190" { set x [expr $x+1]; exp_continue; }
 
1768
        -re ".* 658 1132 78266B28" { set x [expr $x+1]; exp_continue; }
 
1769
        -re ".* 658      12345678" { set x [expr $x+1]; exp_continue; }
 
1770
        -re ".* 658      1190" { set x [expr $x+1]; exp_continue; }
 
1771
        -re ".* 659 113c 78276B28" { set x [expr $x+1]; exp_continue; }
 
1772
        -re ".* 659      12345678" { set x [expr $x+1]; exp_continue; }
 
1773
        -re ".* 659      1190" { set x [expr $x+1]; exp_continue; }
 
1774
        -re ".* 660 1146 6B181234" { set x [expr $x+1]; exp_continue; }
 
1775
        -re ".* 660      1190" { set x [expr $x+1]; exp_continue; }
 
1776
        -re ".* 661 114c 6B381234" { set x [expr $x+1]; exp_continue; }
 
1777
        -re ".* 661      56781190" { set x [expr $x+1]; exp_continue; }
 
1778
        -re ".* 662              " {
 
1779
            if [expr $x == 36] then {
 
1780
                pass "$testname: shar.w ..."
 
1781
            } else {
 
1782
                fail "$testname: shar.w ... ($x)"
 
1783
            }
 
1784
        }
 
1785
        default { fail "$testname: shar.w ... ($x)" }
 
1786
    }
 
1787
 
 
1788
    set x 0
 
1789
    expect {
 
1790
        -re ".* 663 1154 11B1" { set x [expr $x+1]; exp_continue; }
 
1791
        -re ".* 664 1156 01046918" { set x [expr $x+1]; exp_continue; }
 
1792
        -re ".* 664      11B0" { set x [expr $x+1]; exp_continue; }
 
1793
        -re ".* 665 115c 01076918" { set x [expr $x+1]; exp_continue; }
 
1794
        -re ".* 665      11B0" { set x [expr $x+1]; exp_continue; }
 
1795
        -re ".* 666 1162 01046D18" { set x [expr $x+1]; exp_continue; }
 
1796
        -re ".* 666      11B0" { set x [expr $x+1]; exp_continue; }
 
1797
        -re ".* 667 1168 01076D18" { set x [expr $x+1]; exp_continue; }
 
1798
        -re ".* 667      11B0" { set x [expr $x+1]; exp_continue; }
 
1799
        -re ".* 668 116e 01056D18" { set x [expr $x+1]; exp_continue; }
 
1800
        -re ".* 668      11B0" { set x [expr $x+1]; exp_continue; }
 
1801
        -re ".* 669 1174 01066D18" { set x [expr $x+1]; exp_continue; }
 
1802
        -re ".* 669      11B0" { set x [expr $x+1]; exp_continue; }
 
1803
        -re ".* 670 117a 01046F18" { set x [expr $x+1]; exp_continue; }
 
1804
        -re ".* 670      123411B0" { set x [expr $x+1]; exp_continue; }
 
1805
        -re ".* 671 1182 78946B28" { set x [expr $x+1]; exp_continue; }
 
1806
        -re ".* 671      12345678" { set x [expr $x+1]; exp_continue; }
 
1807
        -re ".* 671      11B0" { set x [expr $x+1]; exp_continue; }
 
1808
        -re ".* 672 118c 01056F28" { set x [expr $x+1]; exp_continue; }
 
1809
        -re ".* 672      123411B0" { set x [expr $x+1]; exp_continue; }
 
1810
        -re ".* 673 1194 01066F28" { set x [expr $x+1]; exp_continue; }
 
1811
        -re ".* 673      123411B0" { set x [expr $x+1]; exp_continue; }
 
1812
        -re ".* 674 119c 01076F28" { set x [expr $x+1]; exp_continue; }
 
1813
        -re ".* 674      123411B0" { set x [expr $x+1]; exp_continue; }
 
1814
        -re ".* 675 11a4 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1815
        -re ".* 675      12345678" { set x [expr $x+1]; exp_continue; }
 
1816
        -re ".* 675      11B0" { set x [expr $x+1]; exp_continue; }
 
1817
        -re ".* 676 11ae 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1818
        -re ".* 676      12345678" { set x [expr $x+1]; exp_continue; }
 
1819
        -re ".* 676      11B0" { set x [expr $x+1]; exp_continue; }
 
1820
        -re ".* 677 11b8 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1821
        -re ".* 677      12345678" { set x [expr $x+1]; exp_continue; }
 
1822
        -re ".* 677      11B0" { set x [expr $x+1]; exp_continue; }
 
1823
        -re ".* 678 11c2 01046B08" { set x [expr $x+1]; exp_continue; }
 
1824
        -re ".* 678      123411B0" { set x [expr $x+1]; exp_continue; }
 
1825
        -re ".* 679 11ca 01046B28" { set x [expr $x+1]; exp_continue; }
 
1826
        -re ".* 679      12345678" { set x [expr $x+1]; exp_continue; }
 
1827
        -re ".* 679      11B0" { set x [expr $x+1]; exp_continue; }
 
1828
        -re ".* 680              " {
 
1829
            if [expr $x == 38] then {
 
1830
                pass "$testname: shar.l ..."
 
1831
            } else {
 
1832
                fail "$testname: shar.l ... ($x)"
 
1833
            }
 
1834
        }
 
1835
        default { fail "$testname: shar.l ... ($x)" }
 
1836
    }
 
1837
 
 
1838
    set x 0
 
1839
    expect {
 
1840
        -re ".* 681 11d4 11C1" { set x [expr $x+1]; exp_continue; }
 
1841
        -re ".* 682 11d6 7D1011C0" { set x [expr $x+1]; exp_continue; }
 
1842
        -re ".* 683 11da 01776818" { set x [expr $x+1]; exp_continue; }
 
1843
        -re ".* 683      11C0" { set x [expr $x+1]; exp_continue; }
 
1844
        -re ".* 684 11e0 01746C18" { set x [expr $x+1]; exp_continue; }
 
1845
        -re ".* 684      11C0" { set x [expr $x+1]; exp_continue; }
 
1846
        -re ".* 685 11e6 01776C18" { set x [expr $x+1]; exp_continue; }
 
1847
        -re ".* 685      11C0" { set x [expr $x+1]; exp_continue; }
 
1848
        -re ".* 686 11ec 01756C18" { set x [expr $x+1]; exp_continue; }
 
1849
        -re ".* 686      11C0" { set x [expr $x+1]; exp_continue; }
 
1850
        -re ".* 687 11f2 01766C18" { set x [expr $x+1]; exp_continue; }
 
1851
        -re ".* 687      11C0" { set x [expr $x+1]; exp_continue; }
 
1852
        -re ".* 688 11f8 01746E18" { set x [expr $x+1]; exp_continue; }
 
1853
        -re ".* 688      123411C0" { set x [expr $x+1]; exp_continue; }
 
1854
        -re ".* 689 1200 78146A28" { set x [expr $x+1]; exp_continue; }
 
1855
        -re ".* 689      12345678" { set x [expr $x+1]; exp_continue; }
 
1856
        -re ".* 689      11C0" { set x [expr $x+1]; exp_continue; }
 
1857
        -re ".* 690 120a 01756E28" { set x [expr $x+1]; exp_continue; }
 
1858
        -re ".* 690      123411C0" { set x [expr $x+1]; exp_continue; }
 
1859
        -re ".* 691 1212 01766E28" { set x [expr $x+1]; exp_continue; }
 
1860
        -re ".* 691      123411C0" { set x [expr $x+1]; exp_continue; }
 
1861
        -re ".* 692 121a 01776E28" { set x [expr $x+1]; exp_continue; }
 
1862
        -re ".* 692      123411C0" { set x [expr $x+1]; exp_continue; }
 
1863
        -re ".* 693 1222 78256A28" { set x [expr $x+1]; exp_continue; }
 
1864
        -re ".* 693      12345678" { set x [expr $x+1]; exp_continue; }
 
1865
        -re ".* 693      11C0" { set x [expr $x+1]; exp_continue; }
 
1866
        -re ".* 694 122c 78266A28" { set x [expr $x+1]; exp_continue; }
 
1867
        -re ".* 694      12345678" { set x [expr $x+1]; exp_continue; }
 
1868
        -re ".* 694      11C0" { set x [expr $x+1]; exp_continue; }
 
1869
        -re ".* 695 1236 78276A28" { set x [expr $x+1]; exp_continue; }
 
1870
        -re ".* 695      12345678" { set x [expr $x+1]; exp_continue; }
 
1871
        -re ".* 695      11C0" { set x [expr $x+1]; exp_continue; }
 
1872
        -re ".* 696 1240 7F1211C0" { set x [expr $x+1]; exp_continue; }
 
1873
        -re ".* 697 1244 6A181234" { set x [expr $x+1]; exp_continue; }
 
1874
        -re ".* 697      11C0" { set x [expr $x+1]; exp_continue; }
 
1875
        -re ".* 698 124a 6A381234" { set x [expr $x+1]; exp_continue; }
 
1876
        -re ".* 698      567811C0" { set x [expr $x+1]; exp_continue; }
 
1877
        -re ".* 699              " {
 
1878
            if [expr $x == 37] then {
 
1879
                pass "$testname: shar.b #2, ..."
 
1880
            } else {
 
1881
                fail "$testname: shar.b #2, ... ($x)"
 
1882
            }
 
1883
        }
 
1884
        default { fail "$testname: shar.b #2, ... ($x)" }
 
1885
    }
 
1886
 
 
1887
    set x 0
 
1888
    expect {
 
1889
        -re ".* 700 1252 11D1" { set x [expr $x+1]; exp_continue; }
 
1890
        -re ".* 701 1254 7D9011D0" { set x [expr $x+1]; exp_continue; }
 
1891
        -re ".* 702 1258 01576918" { set x [expr $x+1]; exp_continue; }
 
1892
        -re ".* 702      11D0" { set x [expr $x+1]; exp_continue; }
 
1893
        -re ".* 703 125e 01546D18" { set x [expr $x+1]; exp_continue; }
 
1894
        -re ".* 703      11D0" { set x [expr $x+1]; exp_continue; }
 
1895
        -re ".* 704 1264 01576D18" { set x [expr $x+1]; exp_continue; }
 
1896
        -re ".* 704      11D0" { set x [expr $x+1]; exp_continue; }
 
1897
        -re ".* 705 126a 01556D18" { set x [expr $x+1]; exp_continue; }
 
1898
        -re ".* 705      11D0" { set x [expr $x+1]; exp_continue; }
 
1899
        -re ".* 706 1270 01566D18" { set x [expr $x+1]; exp_continue; }
 
1900
        -re ".* 706      11D0" { set x [expr $x+1]; exp_continue; }
 
1901
        -re ".* 707 1276 01546F18" { set x [expr $x+1]; exp_continue; }
 
1902
        -re ".* 707      123411D0" { set x [expr $x+1]; exp_continue; }
 
1903
        -re ".* 708 127e 78146B28" { set x [expr $x+1]; exp_continue; }
 
1904
        -re ".* 708      12345678" { set x [expr $x+1]; exp_continue; }
 
1905
        -re ".* 708      11D0" { set x [expr $x+1]; exp_continue; }
 
1906
        -re ".* 709 1288 01556F28" { set x [expr $x+1]; exp_continue; }
 
1907
        -re ".* 709      123411D0" { set x [expr $x+1]; exp_continue; }
 
1908
        -re ".* 710 1290 01566F28" { set x [expr $x+1]; exp_continue; }
 
1909
        -re ".* 710      123411D0" { set x [expr $x+1]; exp_continue; }
 
1910
        -re ".* 711 1298 01576F28" { set x [expr $x+1]; exp_continue; }
 
1911
        -re ".* 711      123411D0" { set x [expr $x+1]; exp_continue; }
 
1912
        -re ".* 712 12a0 78256B28" { set x [expr $x+1]; exp_continue; }
 
1913
        -re ".* 712      12345678" { set x [expr $x+1]; exp_continue; }
 
1914
        -re ".* 712      11D0" { set x [expr $x+1]; exp_continue; }
 
1915
        -re ".* 713 12aa 78266B28" { set x [expr $x+1]; exp_continue; }
 
1916
        -re ".* 713      12345678" { set x [expr $x+1]; exp_continue; }
 
1917
        -re ".* 713      11D0" { set x [expr $x+1]; exp_continue; }
 
1918
        -re ".* 714 12b4 78276B28" { set x [expr $x+1]; exp_continue; }
 
1919
        -re ".* 714      12345678" { set x [expr $x+1]; exp_continue; }
 
1920
        -re ".* 714      11D0" { set x [expr $x+1]; exp_continue; }
 
1921
        -re ".* 715 12be 6B181234" { set x [expr $x+1]; exp_continue; }
 
1922
        -re ".* 715      11D0" { set x [expr $x+1]; exp_continue; }
 
1923
        -re ".* 716 12c4 6B381234" { set x [expr $x+1]; exp_continue; }
 
1924
        -re ".* 716      567811D0" { set x [expr $x+1]; exp_continue; }
 
1925
        -re ".* 717              " {
 
1926
            if [expr $x == 36] then {
 
1927
                pass "$testname: shar.w #2, ..."
 
1928
            } else {
 
1929
                fail "$testname: shar.w #2, ... ($x)"
 
1930
            }
 
1931
        }
 
1932
        default { fail "$testname: shar.w #2, ... ($x)" }
 
1933
    }
 
1934
 
 
1935
    set x 0
 
1936
    expect {
 
1937
        -re ".* 718 12cc 11F1" { set x [expr $x+1]; exp_continue; }
 
1938
        -re ".* 719 12ce 01046918" { set x [expr $x+1]; exp_continue; }
 
1939
        -re ".* 719      11F0" { set x [expr $x+1]; exp_continue; }
 
1940
        -re ".* 720 12d4 01076918" { set x [expr $x+1]; exp_continue; }
 
1941
        -re ".* 720      11F0" { set x [expr $x+1]; exp_continue; }
 
1942
        -re ".* 721 12da 01046D18" { set x [expr $x+1]; exp_continue; }
 
1943
        -re ".* 721      11F0" { set x [expr $x+1]; exp_continue; }
 
1944
        -re ".* 722 12e0 01076D18" { set x [expr $x+1]; exp_continue; }
 
1945
        -re ".* 722      11F0" { set x [expr $x+1]; exp_continue; }
 
1946
        -re ".* 723 12e6 01056D18" { set x [expr $x+1]; exp_continue; }
 
1947
        -re ".* 723      11F0" { set x [expr $x+1]; exp_continue; }
 
1948
        -re ".* 724 12ec 01066D18" { set x [expr $x+1]; exp_continue; }
 
1949
        -re ".* 724      11F0" { set x [expr $x+1]; exp_continue; }
 
1950
        -re ".* 725 12f2 01046F18" { set x [expr $x+1]; exp_continue; }
 
1951
        -re ".* 725      123411F0" { set x [expr $x+1]; exp_continue; }
 
1952
        -re ".* 726 12fa 78946B28" { set x [expr $x+1]; exp_continue; }
 
1953
        -re ".* 726      12345678" { set x [expr $x+1]; exp_continue; }
 
1954
        -re ".* 726      11F0" { set x [expr $x+1]; exp_continue; }
 
1955
        -re ".* 727 1304 01056F28" { set x [expr $x+1]; exp_continue; }
 
1956
        -re ".* 727      123411F0" { set x [expr $x+1]; exp_continue; }
 
1957
        -re ".* 728 130c 01066F28" { set x [expr $x+1]; exp_continue; }
 
1958
        -re ".* 728      123411F0" { set x [expr $x+1]; exp_continue; }
 
1959
        -re ".* 729 1314 01076F28" { set x [expr $x+1]; exp_continue; }
 
1960
        -re ".* 729      123411F0" { set x [expr $x+1]; exp_continue; }
 
1961
        -re ".* 730 131c 78A56B28" { set x [expr $x+1]; exp_continue; }
 
1962
        -re ".* 730      12345678" { set x [expr $x+1]; exp_continue; }
 
1963
        -re ".* 730      11F0" { set x [expr $x+1]; exp_continue; }
 
1964
        -re ".* 731 1326 78A66B28" { set x [expr $x+1]; exp_continue; }
 
1965
        -re ".* 731      12345678" { set x [expr $x+1]; exp_continue; }
 
1966
        -re ".* 731      11F0" { set x [expr $x+1]; exp_continue; }
 
1967
        -re ".* 732 1330 78A76B28" { set x [expr $x+1]; exp_continue; }
 
1968
        -re ".* 732      12345678" { set x [expr $x+1]; exp_continue; }
 
1969
        -re ".* 732      11F0" { set x [expr $x+1]; exp_continue; }
 
1970
        -re ".* 733 133a 01046B08" { set x [expr $x+1]; exp_continue; }
 
1971
        -re ".* 733      123411F0" { set x [expr $x+1]; exp_continue; }
 
1972
        -re ".* 734 1342 01046B28" { set x [expr $x+1]; exp_continue; }
 
1973
        -re ".* 734      12345678" { set x [expr $x+1]; exp_continue; }
 
1974
        -re ".* 734      11F0" { set x [expr $x+1]; exp_continue; }
 
1975
        -re ".* 735              " {
 
1976
            if [expr $x == 38] then {
 
1977
                pass "$testname: shar.l #2, ..."
 
1978
            } else {
 
1979
                fail "$testname: shar.l #2, ... ($x)"
 
1980
            }
 
1981
        }
 
1982
        default { fail "$testname: shar.l #2, ... ($x)" }
 
1983
    }
 
1984
 
 
1985
    set x 0
 
1986
    expect {
 
1987
        -re ".* 736 134c 1201" { set x [expr $x+1]; exp_continue; }
 
1988
        -re ".* 737 134e 7D101200" { set x [expr $x+1]; exp_continue; }
 
1989
        -re ".* 738 1352 01776818" { set x [expr $x+1]; exp_continue; }
 
1990
        -re ".* 738      1200" { set x [expr $x+1]; exp_continue; }
 
1991
        -re ".* 739 1358 01746C18" { set x [expr $x+1]; exp_continue; }
 
1992
        -re ".* 739      1200" { set x [expr $x+1]; exp_continue; }
 
1993
        -re ".* 740 135e 01776C18" { set x [expr $x+1]; exp_continue; }
 
1994
        -re ".* 740      1200" { set x [expr $x+1]; exp_continue; }
 
1995
        -re ".* 741 1364 01756C18" { set x [expr $x+1]; exp_continue; }
 
1996
        -re ".* 741      1200" { set x [expr $x+1]; exp_continue; }
 
1997
        -re ".* 742 136a 01766C18" { set x [expr $x+1]; exp_continue; }
 
1998
        -re ".* 742      1200" { set x [expr $x+1]; exp_continue; }
 
1999
        -re ".* 743 1370 01746E18" { set x [expr $x+1]; exp_continue; }
 
2000
        -re ".* 743      12341200" { set x [expr $x+1]; exp_continue; }
 
2001
        -re ".* 744 1378 78146A28" { set x [expr $x+1]; exp_continue; }
 
2002
        -re ".* 744      12345678" { set x [expr $x+1]; exp_continue; }
 
2003
        -re ".* 744      1200" { set x [expr $x+1]; exp_continue; }
 
2004
        -re ".* 745 1382 01756E28" { set x [expr $x+1]; exp_continue; }
 
2005
        -re ".* 745      12341200" { set x [expr $x+1]; exp_continue; }
 
2006
        -re ".* 746 138a 01766E28" { set x [expr $x+1]; exp_continue; }
 
2007
        -re ".* 746      12341200" { set x [expr $x+1]; exp_continue; }
 
2008
        -re ".* 747 1392 01776E28" { set x [expr $x+1]; exp_continue; }
 
2009
        -re ".* 747      12341200" { set x [expr $x+1]; exp_continue; }
 
2010
        -re ".* 748 139a 78256A28" { set x [expr $x+1]; exp_continue; }
 
2011
        -re ".* 748      12345678" { set x [expr $x+1]; exp_continue; }
 
2012
        -re ".* 748      1200" { set x [expr $x+1]; exp_continue; }
 
2013
        -re ".* 749 13a4 78266A28" { set x [expr $x+1]; exp_continue; }
 
2014
        -re ".* 749      12345678" { set x [expr $x+1]; exp_continue; }
 
2015
        -re ".* 749      1200" { set x [expr $x+1]; exp_continue; }
 
2016
        -re ".* 750 13ae 78276A28" { set x [expr $x+1]; exp_continue; }
 
2017
        -re ".* 750      12345678" { set x [expr $x+1]; exp_continue; }
 
2018
        -re ".* 750      1200" { set x [expr $x+1]; exp_continue; }
 
2019
        -re ".* 751 13b8 7F121200" { set x [expr $x+1]; exp_continue; }
 
2020
        -re ".* 752 13bc 6A181234" { set x [expr $x+1]; exp_continue; }
 
2021
        -re ".* 752      1200" { set x [expr $x+1]; exp_continue; }
 
2022
        -re ".* 753 13c2 6A381234" { set x [expr $x+1]; exp_continue; }
 
2023
        -re ".* 753      56781200" { set x [expr $x+1]; exp_continue; }
 
2024
        -re ".* 754              " {
 
2025
            if [expr $x == 37] then {
 
2026
                pass "$testname: rotxl.b ..."
 
2027
            } else {
 
2028
                fail "$testname: rotxl.b ... ($x)"
 
2029
            }
 
2030
        }
 
2031
        default { fail "$testname: rotxl.b ... ($x)" }
 
2032
    }
 
2033
 
 
2034
    set x 0
 
2035
    expect {
 
2036
        -re ".* 755 13ca 1211" { set x [expr $x+1]; exp_continue; }
 
2037
        -re ".* 756 13cc 7D901210" { set x [expr $x+1]; exp_continue; }
 
2038
        -re ".* 757 13d0 01576918" { set x [expr $x+1]; exp_continue; }
 
2039
        -re ".* 757      1210" { set x [expr $x+1]; exp_continue; }
 
2040
        -re ".* 758 13d6 01546D18" { set x [expr $x+1]; exp_continue; }
 
2041
        -re ".* 758      1210" { set x [expr $x+1]; exp_continue; }
 
2042
        -re ".* 759 13dc 01576D18" { set x [expr $x+1]; exp_continue; }
 
2043
        -re ".* 759      1210" { set x [expr $x+1]; exp_continue; }
 
2044
        -re ".* 760 13e2 01556D18" { set x [expr $x+1]; exp_continue; }
 
2045
        -re ".* 760      1210" { set x [expr $x+1]; exp_continue; }
 
2046
        -re ".* 761 13e8 01566D18" { set x [expr $x+1]; exp_continue; }
 
2047
        -re ".* 761      1210" { set x [expr $x+1]; exp_continue; }
 
2048
        -re ".* 762 13ee 01546F18" { set x [expr $x+1]; exp_continue; }
 
2049
        -re ".* 762      12341210" { set x [expr $x+1]; exp_continue; }
 
2050
        -re ".* 763 13f6 78146B28" { set x [expr $x+1]; exp_continue; }
 
2051
        -re ".* 763      12345678" { set x [expr $x+1]; exp_continue; }
 
2052
        -re ".* 763      1210" { set x [expr $x+1]; exp_continue; }
 
2053
        -re ".* 764 1400 01556F28" { set x [expr $x+1]; exp_continue; }
 
2054
        -re ".* 764      12341210" { set x [expr $x+1]; exp_continue; }
 
2055
        -re ".* 765 1408 01566F28" { set x [expr $x+1]; exp_continue; }
 
2056
        -re ".* 765      12341210" { set x [expr $x+1]; exp_continue; }
 
2057
        -re ".* 766 1410 01576F28" { set x [expr $x+1]; exp_continue; }
 
2058
        -re ".* 766      12341210" { set x [expr $x+1]; exp_continue; }
 
2059
        -re ".* 767 1418 78256B28" { set x [expr $x+1]; exp_continue; }
 
2060
        -re ".* 767      12345678" { set x [expr $x+1]; exp_continue; }
 
2061
        -re ".* 767      1210" { set x [expr $x+1]; exp_continue; }
 
2062
        -re ".* 768 1422 78266B28" { set x [expr $x+1]; exp_continue; }
 
2063
        -re ".* 768      12345678" { set x [expr $x+1]; exp_continue; }
 
2064
        -re ".* 768      1210" { set x [expr $x+1]; exp_continue; }
 
2065
        -re ".* 769 142c 78276B28" { set x [expr $x+1]; exp_continue; }
 
2066
        -re ".* 769      12345678" { set x [expr $x+1]; exp_continue; }
 
2067
        -re ".* 769      1210" { set x [expr $x+1]; exp_continue; }
 
2068
        -re ".* 770 1436 6B181234" { set x [expr $x+1]; exp_continue; }
 
2069
        -re ".* 770      1210" { set x [expr $x+1]; exp_continue; }
 
2070
        -re ".* 771 143c 6B381234" { set x [expr $x+1]; exp_continue; }
 
2071
        -re ".* 771      56781210" { set x [expr $x+1]; exp_continue; }
 
2072
        -re ".* 772              " {
 
2073
            if [expr $x == 36] then {
 
2074
                pass "$testname: rotxl.w ..."
 
2075
            } else {
 
2076
                fail "$testname: rotxl.w ... ($x)"
 
2077
            }
 
2078
        }
 
2079
        default { fail "$testname: rotxl.w ... ($x)" }
 
2080
    }
 
2081
 
 
2082
    set x 0
 
2083
    expect {
 
2084
        -re ".* 773 1444 1231" { set x [expr $x+1]; exp_continue; }
 
2085
        -re ".* 774 1446 01046918" { set x [expr $x+1]; exp_continue; }
 
2086
        -re ".* 774      1230" { set x [expr $x+1]; exp_continue; }
 
2087
        -re ".* 775 144c 01076918" { set x [expr $x+1]; exp_continue; }
 
2088
        -re ".* 775      1230" { set x [expr $x+1]; exp_continue; }
 
2089
        -re ".* 776 1452 01046D18" { set x [expr $x+1]; exp_continue; }
 
2090
        -re ".* 776      1230" { set x [expr $x+1]; exp_continue; }
 
2091
        -re ".* 777 1458 01076D18" { set x [expr $x+1]; exp_continue; }
 
2092
        -re ".* 777      1230" { set x [expr $x+1]; exp_continue; }
 
2093
        -re ".* 778 145e 01056D18" { set x [expr $x+1]; exp_continue; }
 
2094
        -re ".* 778      1230" { set x [expr $x+1]; exp_continue; }
 
2095
        -re ".* 779 1464 01066D18" { set x [expr $x+1]; exp_continue; }
 
2096
        -re ".* 779      1230" { set x [expr $x+1]; exp_continue; }
 
2097
        -re ".* 780 146a 01046F18" { set x [expr $x+1]; exp_continue; }
 
2098
        -re ".* 780      12341230" { set x [expr $x+1]; exp_continue; }
 
2099
        -re ".* 781 1472 78946B28" { set x [expr $x+1]; exp_continue; }
 
2100
        -re ".* 781      12345678" { set x [expr $x+1]; exp_continue; }
 
2101
        -re ".* 781      1230" { set x [expr $x+1]; exp_continue; }
 
2102
        -re ".* 782 147c 01056F28" { set x [expr $x+1]; exp_continue; }
 
2103
        -re ".* 782      12341230" { set x [expr $x+1]; exp_continue; }
 
2104
        -re ".* 783 1484 01066F28" { set x [expr $x+1]; exp_continue; }
 
2105
        -re ".* 783      12341230" { set x [expr $x+1]; exp_continue; }
 
2106
        -re ".* 784 148c 01076F28" { set x [expr $x+1]; exp_continue; }
 
2107
        -re ".* 784      12341230" { set x [expr $x+1]; exp_continue; }
 
2108
        -re ".* 785 1494 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2109
        -re ".* 785      12345678" { set x [expr $x+1]; exp_continue; }
 
2110
        -re ".* 785      1230" { set x [expr $x+1]; exp_continue; }
 
2111
        -re ".* 786 149e 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2112
        -re ".* 786      12345678" { set x [expr $x+1]; exp_continue; }
 
2113
        -re ".* 786      1230" { set x [expr $x+1]; exp_continue; }
 
2114
        -re ".* 787 14a8 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2115
        -re ".* 787      12345678" { set x [expr $x+1]; exp_continue; }
 
2116
        -re ".* 787      1230" { set x [expr $x+1]; exp_continue; }
 
2117
        -re ".* 788 14b2 01046B08" { set x [expr $x+1]; exp_continue; }
 
2118
        -re ".* 788      12341230" { set x [expr $x+1]; exp_continue; }
 
2119
        -re ".* 789 14ba 01046B28" { set x [expr $x+1]; exp_continue; }
 
2120
        -re ".* 789      12345678" { set x [expr $x+1]; exp_continue; }
 
2121
        -re ".* 789      1230" { set x [expr $x+1]; exp_continue; }
 
2122
        -re ".* 790              " {
 
2123
            if [expr $x == 38] then {
 
2124
                pass "$testname: rotxl.l ..."
 
2125
            } else {
 
2126
                fail "$testname: rotxl.l ... ($x)"
 
2127
            }
 
2128
        }
 
2129
        default { fail "$testname: rotxl.l ... ($x)" }
 
2130
    }
 
2131
 
 
2132
    set x 0
 
2133
    expect {
 
2134
        -re ".* 791 14c4 1241" { set x [expr $x+1]; exp_continue; }
 
2135
        -re ".* 792 14c6 7D101240" { set x [expr $x+1]; exp_continue; }
 
2136
        -re ".* 793 14ca 01776818" { set x [expr $x+1]; exp_continue; }
 
2137
        -re ".* 793      1240" { set x [expr $x+1]; exp_continue; }
 
2138
        -re ".* 794 14d0 01746C18" { set x [expr $x+1]; exp_continue; }
 
2139
        -re ".* 794      1240" { set x [expr $x+1]; exp_continue; }
 
2140
        -re ".* 795 14d6 01776C18" { set x [expr $x+1]; exp_continue; }
 
2141
        -re ".* 795      1240" { set x [expr $x+1]; exp_continue; }
 
2142
        -re ".* 796 14dc 01756C18" { set x [expr $x+1]; exp_continue; }
 
2143
        -re ".* 796      1240" { set x [expr $x+1]; exp_continue; }
 
2144
        -re ".* 797 14e2 01766C18" { set x [expr $x+1]; exp_continue; }
 
2145
        -re ".* 797      1240" { set x [expr $x+1]; exp_continue; }
 
2146
        -re ".* 798 14e8 01746E18" { set x [expr $x+1]; exp_continue; }
 
2147
        -re ".* 798      12341240" { set x [expr $x+1]; exp_continue; }
 
2148
        -re ".* 799 14f0 78146A28" { set x [expr $x+1]; exp_continue; }
 
2149
        -re ".* 799      12345678" { set x [expr $x+1]; exp_continue; }
 
2150
        -re ".* 799      1240" { set x [expr $x+1]; exp_continue; }
 
2151
        -re ".* 800 14fa 01756E28" { set x [expr $x+1]; exp_continue; }
 
2152
        -re ".* 800      12341240" { set x [expr $x+1]; exp_continue; }
 
2153
        -re ".* 801 1502 01766E28" { set x [expr $x+1]; exp_continue; }
 
2154
        -re ".* 801      12341240" { set x [expr $x+1]; exp_continue; }
 
2155
        -re ".* 802 150a 01776E28" { set x [expr $x+1]; exp_continue; }
 
2156
        -re ".* 802      12341240" { set x [expr $x+1]; exp_continue; }
 
2157
        -re ".* 803 1512 78256A28" { set x [expr $x+1]; exp_continue; }
 
2158
        -re ".* 803      12345678" { set x [expr $x+1]; exp_continue; }
 
2159
        -re ".* 803      1240" { set x [expr $x+1]; exp_continue; }
 
2160
        -re ".* 804 151c 78266A28" { set x [expr $x+1]; exp_continue; }
 
2161
        -re ".* 804      12345678" { set x [expr $x+1]; exp_continue; }
 
2162
        -re ".* 804      1240" { set x [expr $x+1]; exp_continue; }
 
2163
        -re ".* 805 1526 78276A28" { set x [expr $x+1]; exp_continue; }
 
2164
        -re ".* 805      12345678" { set x [expr $x+1]; exp_continue; }
 
2165
        -re ".* 805      1240" { set x [expr $x+1]; exp_continue; }
 
2166
        -re ".* 806 1530 7F121240" { set x [expr $x+1]; exp_continue; }
 
2167
        -re ".* 807 1534 6A181234" { set x [expr $x+1]; exp_continue; }
 
2168
        -re ".* 807      1240" { set x [expr $x+1]; exp_continue; }
 
2169
        -re ".* 808 153a 6A381234" { set x [expr $x+1]; exp_continue; }
 
2170
        -re ".* 808      56781240" { set x [expr $x+1]; exp_continue; }
 
2171
        -re ".* 809              " {
 
2172
            if [expr $x == 37] then {
 
2173
                pass "$testname: rotxl.b #2, ..."
 
2174
            } else {
 
2175
                fail "$testname: rotxl.b #2, ... ($x)"
 
2176
            }
 
2177
        }
 
2178
        default { fail "$testname: rotxl.b #2, ... ($x)" }
 
2179
    }
 
2180
 
 
2181
    set x 0
 
2182
    expect {
 
2183
        -re ".* 810 1542 1251" { set x [expr $x+1]; exp_continue; }
 
2184
        -re ".* 811 1544 7D901250" { set x [expr $x+1]; exp_continue; }
 
2185
        -re ".* 812 1548 01576918" { set x [expr $x+1]; exp_continue; }
 
2186
        -re ".* 812      1250" { set x [expr $x+1]; exp_continue; }
 
2187
        -re ".* 813 154e 01546D18" { set x [expr $x+1]; exp_continue; }
 
2188
        -re ".* 813      1250" { set x [expr $x+1]; exp_continue; }
 
2189
        -re ".* 814 1554 01576D18" { set x [expr $x+1]; exp_continue; }
 
2190
        -re ".* 814      1250" { set x [expr $x+1]; exp_continue; }
 
2191
        -re ".* 815 155a 01556D18" { set x [expr $x+1]; exp_continue; }
 
2192
        -re ".* 815      1250" { set x [expr $x+1]; exp_continue; }
 
2193
        -re ".* 816 1560 01566D18" { set x [expr $x+1]; exp_continue; }
 
2194
        -re ".* 816      1250" { set x [expr $x+1]; exp_continue; }
 
2195
        -re ".* 817 1566 01546F18" { set x [expr $x+1]; exp_continue; }
 
2196
        -re ".* 817      12341250" { set x [expr $x+1]; exp_continue; }
 
2197
        -re ".* 818 156e 78146B28" { set x [expr $x+1]; exp_continue; }
 
2198
        -re ".* 818      12345678" { set x [expr $x+1]; exp_continue; }
 
2199
        -re ".* 818      1250" { set x [expr $x+1]; exp_continue; }
 
2200
        -re ".* 819 1578 01556F28" { set x [expr $x+1]; exp_continue; }
 
2201
        -re ".* 819      12341250" { set x [expr $x+1]; exp_continue; }
 
2202
        -re ".* 820 1580 01566F28" { set x [expr $x+1]; exp_continue; }
 
2203
        -re ".* 820      12341250" { set x [expr $x+1]; exp_continue; }
 
2204
        -re ".* 821 1588 01576F28" { set x [expr $x+1]; exp_continue; }
 
2205
        -re ".* 821      12341250" { set x [expr $x+1]; exp_continue; }
 
2206
        -re ".* 822 1590 78256B28" { set x [expr $x+1]; exp_continue; }
 
2207
        -re ".* 822      12345678" { set x [expr $x+1]; exp_continue; }
 
2208
        -re ".* 822      1250" { set x [expr $x+1]; exp_continue; }
 
2209
        -re ".* 823 159a 78266B28" { set x [expr $x+1]; exp_continue; }
 
2210
        -re ".* 823      12345678" { set x [expr $x+1]; exp_continue; }
 
2211
        -re ".* 823      1250" { set x [expr $x+1]; exp_continue; }
 
2212
        -re ".* 824 15a4 78276B28" { set x [expr $x+1]; exp_continue; }
 
2213
        -re ".* 824      12345678" { set x [expr $x+1]; exp_continue; }
 
2214
        -re ".* 824      1250" { set x [expr $x+1]; exp_continue; }
 
2215
        -re ".* 825 15ae 6B181234" { set x [expr $x+1]; exp_continue; }
 
2216
        -re ".* 825      1250" { set x [expr $x+1]; exp_continue; }
 
2217
        -re ".* 826 15b4 6B381234" { set x [expr $x+1]; exp_continue; }
 
2218
        -re ".* 826      56781250" { set x [expr $x+1]; exp_continue; }
 
2219
        -re ".* 827              " {
 
2220
            if [expr $x == 36] then {
 
2221
                pass "$testname: rotxl.w #2, ..."
 
2222
            } else {
 
2223
                fail "$testname: rotxl.w #2, ... ($x)"
 
2224
            }
 
2225
        }
 
2226
        default { fail "$testname: rotxl.w #2, ... ($x)" }
 
2227
    }
 
2228
 
 
2229
    set x 0
 
2230
    expect {
 
2231
        -re ".* 828 15bc 1271" { set x [expr $x+1]; exp_continue; }
 
2232
        -re ".* 829 15be 01046918" { set x [expr $x+1]; exp_continue; }
 
2233
        -re ".* 829      1270" { set x [expr $x+1]; exp_continue; }
 
2234
        -re ".* 830 15c4 01076918" { set x [expr $x+1]; exp_continue; }
 
2235
        -re ".* 830      1270" { set x [expr $x+1]; exp_continue; }
 
2236
        -re ".* 831 15ca 01046D18" { set x [expr $x+1]; exp_continue; }
 
2237
        -re ".* 831      1270" { set x [expr $x+1]; exp_continue; }
 
2238
        -re ".* 832 15d0 01076D18" { set x [expr $x+1]; exp_continue; }
 
2239
        -re ".* 832      1270" { set x [expr $x+1]; exp_continue; }
 
2240
        -re ".* 833 15d6 01056D18" { set x [expr $x+1]; exp_continue; }
 
2241
        -re ".* 833      1270" { set x [expr $x+1]; exp_continue; }
 
2242
        -re ".* 834 15dc 01066D18" { set x [expr $x+1]; exp_continue; }
 
2243
        -re ".* 834      1270" { set x [expr $x+1]; exp_continue; }
 
2244
        -re ".* 835 15e2 01046F18" { set x [expr $x+1]; exp_continue; }
 
2245
        -re ".* 835      12341270" { set x [expr $x+1]; exp_continue; }
 
2246
        -re ".* 836 15ea 78946B28" { set x [expr $x+1]; exp_continue; }
 
2247
        -re ".* 836      12345678" { set x [expr $x+1]; exp_continue; }
 
2248
        -re ".* 836      1270" { set x [expr $x+1]; exp_continue; }
 
2249
        -re ".* 837 15f4 01056F28" { set x [expr $x+1]; exp_continue; }
 
2250
        -re ".* 837      12341270" { set x [expr $x+1]; exp_continue; }
 
2251
        -re ".* 838 15fc 01066F28" { set x [expr $x+1]; exp_continue; }
 
2252
        -re ".* 838      12341270" { set x [expr $x+1]; exp_continue; }
 
2253
        -re ".* 839 1604 01076F28" { set x [expr $x+1]; exp_continue; }
 
2254
        -re ".* 839      12341270" { set x [expr $x+1]; exp_continue; }
 
2255
        -re ".* 840 160c 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2256
        -re ".* 840      12345678" { set x [expr $x+1]; exp_continue; }
 
2257
        -re ".* 840      1270" { set x [expr $x+1]; exp_continue; }
 
2258
        -re ".* 841 1616 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2259
        -re ".* 841      12345678" { set x [expr $x+1]; exp_continue; }
 
2260
        -re ".* 841      1270" { set x [expr $x+1]; exp_continue; }
 
2261
        -re ".* 842 1620 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2262
        -re ".* 842      12345678" { set x [expr $x+1]; exp_continue; }
 
2263
        -re ".* 842      1270" { set x [expr $x+1]; exp_continue; }
 
2264
        -re ".* 843 162a 01046B08" { set x [expr $x+1]; exp_continue; }
 
2265
        -re ".* 843      12341270" { set x [expr $x+1]; exp_continue; }
 
2266
        -re ".* 844 1632 01046B28" { set x [expr $x+1]; exp_continue; }
 
2267
        -re ".* 844      12345678" { set x [expr $x+1]; exp_continue; }
 
2268
        -re ".* 844      1270" { set x [expr $x+1]; exp_continue; }
 
2269
        -re ".* 845              " {
 
2270
            if [expr $x == 38] then {
 
2271
                pass "$testname: rotxl.l #2, ..."
 
2272
            } else {
 
2273
                fail "$testname: rotxl.l #2, ... ($x)"
 
2274
            }
 
2275
        }
 
2276
        default { fail "$testname: rotxl.l #2, ... ($x)" }
 
2277
    }
 
2278
 
 
2279
    set x 0
 
2280
    expect {
 
2281
        -re ".* 846 163c 1301" { set x [expr $x+1]; exp_continue; }
 
2282
        -re ".* 847 163e 7D101300" { set x [expr $x+1]; exp_continue; }
 
2283
        -re ".* 848 1642 01776818" { set x [expr $x+1]; exp_continue; }
 
2284
        -re ".* 848      1300" { set x [expr $x+1]; exp_continue; }
 
2285
        -re ".* 849 1648 01746C18" { set x [expr $x+1]; exp_continue; }
 
2286
        -re ".* 849      1300" { set x [expr $x+1]; exp_continue; }
 
2287
        -re ".* 850 164e 01776C18" { set x [expr $x+1]; exp_continue; }
 
2288
        -re ".* 850      1300" { set x [expr $x+1]; exp_continue; }
 
2289
        -re ".* 851 1654 01756C18" { set x [expr $x+1]; exp_continue; }
 
2290
        -re ".* 851      1300" { set x [expr $x+1]; exp_continue; }
 
2291
        -re ".* 852 165a 01766C18" { set x [expr $x+1]; exp_continue; }
 
2292
        -re ".* 852      1300" { set x [expr $x+1]; exp_continue; }
 
2293
        -re ".* 853 1660 01746E18" { set x [expr $x+1]; exp_continue; }
 
2294
        -re ".* 853      12341300" { set x [expr $x+1]; exp_continue; }
 
2295
        -re ".* 854 1668 78146A28" { set x [expr $x+1]; exp_continue; }
 
2296
        -re ".* 854      12345678" { set x [expr $x+1]; exp_continue; }
 
2297
        -re ".* 854      1300" { set x [expr $x+1]; exp_continue; }
 
2298
        -re ".* 855 1672 01756E28" { set x [expr $x+1]; exp_continue; }
 
2299
        -re ".* 855      12341300" { set x [expr $x+1]; exp_continue; }
 
2300
        -re ".* 856 167a 01766E28" { set x [expr $x+1]; exp_continue; }
 
2301
        -re ".* 856      12341300" { set x [expr $x+1]; exp_continue; }
 
2302
        -re ".* 857 1682 01776E28" { set x [expr $x+1]; exp_continue; }
 
2303
        -re ".* 857      12341300" { set x [expr $x+1]; exp_continue; }
 
2304
        -re ".* 858 168a 78256A28" { set x [expr $x+1]; exp_continue; }
 
2305
        -re ".* 858      12345678" { set x [expr $x+1]; exp_continue; }
 
2306
        -re ".* 858      1300" { set x [expr $x+1]; exp_continue; }
 
2307
        -re ".* 859 1694 78266A28" { set x [expr $x+1]; exp_continue; }
 
2308
        -re ".* 859      12345678" { set x [expr $x+1]; exp_continue; }
 
2309
        -re ".* 859      1300" { set x [expr $x+1]; exp_continue; }
 
2310
        -re ".* 860 169e 78276A28" { set x [expr $x+1]; exp_continue; }
 
2311
        -re ".* 860      12345678" { set x [expr $x+1]; exp_continue; }
 
2312
        -re ".* 860      1300" { set x [expr $x+1]; exp_continue; }
 
2313
        -re ".* 861 16a8 7F121300" { set x [expr $x+1]; exp_continue; }
 
2314
        -re ".* 862 16ac 6A181234" { set x [expr $x+1]; exp_continue; }
 
2315
        -re ".* 862      1300" { set x [expr $x+1]; exp_continue; }
 
2316
        -re ".* 863 16b2 6A381234" { set x [expr $x+1]; exp_continue; }
 
2317
        -re ".* 863      56781300" { set x [expr $x+1]; exp_continue; }
 
2318
        -re ".* 864              " {
 
2319
            if [expr $x == 37] then {
 
2320
                pass "$testname: rotxr.b ..."
 
2321
            } else {
 
2322
                fail "$testname: rotxr.b ... ($x)"
 
2323
            }
 
2324
        }
 
2325
        default { fail "$testname: rotxr.b ... ($x)" }
 
2326
    }
 
2327
 
 
2328
    set x 0
 
2329
    expect {
 
2330
        -re ".* 865 16ba 1311" { set x [expr $x+1]; exp_continue; }
 
2331
        -re ".* 866 16bc 7D901310" { set x [expr $x+1]; exp_continue; }
 
2332
        -re ".* 867 16c0 01576918" { set x [expr $x+1]; exp_continue; }
 
2333
        -re ".* 867      1310" { set x [expr $x+1]; exp_continue; }
 
2334
        -re ".* 868 16c6 01546D18" { set x [expr $x+1]; exp_continue; }
 
2335
        -re ".* 868      1310" { set x [expr $x+1]; exp_continue; }
 
2336
        -re ".* 869 16cc 01576D18" { set x [expr $x+1]; exp_continue; }
 
2337
        -re ".* 869      1310" { set x [expr $x+1]; exp_continue; }
 
2338
        -re ".* 870 16d2 01556D18" { set x [expr $x+1]; exp_continue; }
 
2339
        -re ".* 870      1310" { set x [expr $x+1]; exp_continue; }
 
2340
        -re ".* 871 16d8 01566D18" { set x [expr $x+1]; exp_continue; }
 
2341
        -re ".* 871      1310" { set x [expr $x+1]; exp_continue; }
 
2342
        -re ".* 872 16de 01546F18" { set x [expr $x+1]; exp_continue; }
 
2343
        -re ".* 872      12341310" { set x [expr $x+1]; exp_continue; }
 
2344
        -re ".* 873 16e6 78146B28" { set x [expr $x+1]; exp_continue; }
 
2345
        -re ".* 873      12345678" { set x [expr $x+1]; exp_continue; }
 
2346
        -re ".* 873      1310" { set x [expr $x+1]; exp_continue; }
 
2347
        -re ".* 874 16f0 01556F28" { set x [expr $x+1]; exp_continue; }
 
2348
        -re ".* 874      12341310" { set x [expr $x+1]; exp_continue; }
 
2349
        -re ".* 875 16f8 01566F28" { set x [expr $x+1]; exp_continue; }
 
2350
        -re ".* 875      12341310" { set x [expr $x+1]; exp_continue; }
 
2351
        -re ".* 876 1700 01576F28" { set x [expr $x+1]; exp_continue; }
 
2352
        -re ".* 876      12341310" { set x [expr $x+1]; exp_continue; }
 
2353
        -re ".* 877 1708 78256B28" { set x [expr $x+1]; exp_continue; }
 
2354
        -re ".* 877      12345678" { set x [expr $x+1]; exp_continue; }
 
2355
        -re ".* 877      1310" { set x [expr $x+1]; exp_continue; }
 
2356
        -re ".* 878 1712 78266B28" { set x [expr $x+1]; exp_continue; }
 
2357
        -re ".* 878      12345678" { set x [expr $x+1]; exp_continue; }
 
2358
        -re ".* 878      1310" { set x [expr $x+1]; exp_continue; }
 
2359
        -re ".* 879 171c 78276B28" { set x [expr $x+1]; exp_continue; }
 
2360
        -re ".* 879      12345678" { set x [expr $x+1]; exp_continue; }
 
2361
        -re ".* 879      1310" { set x [expr $x+1]; exp_continue; }
 
2362
        -re ".* 880 1726 6B181234" { set x [expr $x+1]; exp_continue; }
 
2363
        -re ".* 880      1310" { set x [expr $x+1]; exp_continue; }
 
2364
        -re ".* 881 172c 6B381234" { set x [expr $x+1]; exp_continue; }
 
2365
        -re ".* 881      56781310" { set x [expr $x+1]; exp_continue; }
 
2366
        -re ".* 882              " {
 
2367
            if [expr $x == 36] then {
 
2368
                pass "$testname: rotxr.w ..."
 
2369
            } else {
 
2370
                fail "$testname: rotxr.w ... ($x)"
 
2371
            }
 
2372
        }
 
2373
        default { fail "$testname: rotxr.w ... ($x)" }
 
2374
    }
 
2375
 
 
2376
    set x 0
 
2377
    expect {
 
2378
        -re ".* 883 1734 1331" { set x [expr $x+1]; exp_continue; }
 
2379
        -re ".* 884 1736 01046918" { set x [expr $x+1]; exp_continue; }
 
2380
        -re ".* 884      1330" { set x [expr $x+1]; exp_continue; }
 
2381
        -re ".* 885 173c 01076918" { set x [expr $x+1]; exp_continue; }
 
2382
        -re ".* 885      1330" { set x [expr $x+1]; exp_continue; }
 
2383
        -re ".* 886 1742 01046D18" { set x [expr $x+1]; exp_continue; }
 
2384
        -re ".* 886      1330" { set x [expr $x+1]; exp_continue; }
 
2385
        -re ".* 887 1748 01076D18" { set x [expr $x+1]; exp_continue; }
 
2386
        -re ".* 887      1330" { set x [expr $x+1]; exp_continue; }
 
2387
        -re ".* 888 174e 01056D18" { set x [expr $x+1]; exp_continue; }
 
2388
        -re ".* 888      1330" { set x [expr $x+1]; exp_continue; }
 
2389
        -re ".* 889 1754 01066D18" { set x [expr $x+1]; exp_continue; }
 
2390
        -re ".* 889      1330" { set x [expr $x+1]; exp_continue; }
 
2391
        -re ".* 890 175a 01046F18" { set x [expr $x+1]; exp_continue; }
 
2392
        -re ".* 890      12341330" { set x [expr $x+1]; exp_continue; }
 
2393
        -re ".* 891 1762 78946B28" { set x [expr $x+1]; exp_continue; }
 
2394
        -re ".* 891      12345678" { set x [expr $x+1]; exp_continue; }
 
2395
        -re ".* 891      1330" { set x [expr $x+1]; exp_continue; }
 
2396
        -re ".* 892 176c 01056F28" { set x [expr $x+1]; exp_continue; }
 
2397
        -re ".* 892      12341330" { set x [expr $x+1]; exp_continue; }
 
2398
        -re ".* 893 1774 01066F28" { set x [expr $x+1]; exp_continue; }
 
2399
        -re ".* 893      12341330" { set x [expr $x+1]; exp_continue; }
 
2400
        -re ".* 894 177c 01076F28" { set x [expr $x+1]; exp_continue; }
 
2401
        -re ".* 894      12341330" { set x [expr $x+1]; exp_continue; }
 
2402
        -re ".* 895 1784 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2403
        -re ".* 895      12345678" { set x [expr $x+1]; exp_continue; }
 
2404
        -re ".* 895      1330" { set x [expr $x+1]; exp_continue; }
 
2405
        -re ".* 896 178e 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2406
        -re ".* 896      12345678" { set x [expr $x+1]; exp_continue; }
 
2407
        -re ".* 896      1330" { set x [expr $x+1]; exp_continue; }
 
2408
        -re ".* 897 1798 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2409
        -re ".* 897      12345678" { set x [expr $x+1]; exp_continue; }
 
2410
        -re ".* 897      1330" { set x [expr $x+1]; exp_continue; }
 
2411
        -re ".* 898 17a2 01046B08" { set x [expr $x+1]; exp_continue; }
 
2412
        -re ".* 898      12341330" { set x [expr $x+1]; exp_continue; }
 
2413
        -re ".* 899 17aa 01046B28" { set x [expr $x+1]; exp_continue; }
 
2414
        -re ".* 899      12345678" { set x [expr $x+1]; exp_continue; }
 
2415
        -re ".* 899      1330" { set x [expr $x+1]; exp_continue; }
 
2416
        -re ".* 900              " {
 
2417
            if [expr $x == 38] then {
 
2418
                pass "$testname: rotxr.l ..."
 
2419
            } else {
 
2420
                fail "$testname: rotxr.l ... ($x)"
 
2421
            }
 
2422
        }
 
2423
        default { fail "$testname: rotxr.l ... ($x)" }
 
2424
    }
 
2425
 
 
2426
    set x 0
 
2427
    expect {
 
2428
        -re ".* 901 17b4 1341" { set x [expr $x+1]; exp_continue; }
 
2429
        -re ".* 902 17b6 7D101340" { set x [expr $x+1]; exp_continue; }
 
2430
        -re ".* 903 17ba 01776818" { set x [expr $x+1]; exp_continue; }
 
2431
        -re ".* 903      1340" { set x [expr $x+1]; exp_continue; }
 
2432
        -re ".* 904 17c0 01746C18" { set x [expr $x+1]; exp_continue; }
 
2433
        -re ".* 904      1340" { set x [expr $x+1]; exp_continue; }
 
2434
        -re ".* 905 17c6 01776C18" { set x [expr $x+1]; exp_continue; }
 
2435
        -re ".* 905      1340" { set x [expr $x+1]; exp_continue; }
 
2436
        -re ".* 906 17cc 01756C18" { set x [expr $x+1]; exp_continue; }
 
2437
        -re ".* 906      1340" { set x [expr $x+1]; exp_continue; }
 
2438
        -re ".* 907 17d2 01766C18" { set x [expr $x+1]; exp_continue; }
 
2439
        -re ".* 907      1340" { set x [expr $x+1]; exp_continue; }
 
2440
        -re ".* 908 17d8 01746E18" { set x [expr $x+1]; exp_continue; }
 
2441
        -re ".* 908      12341340" { set x [expr $x+1]; exp_continue; }
 
2442
        -re ".* 909 17e0 78146A28" { set x [expr $x+1]; exp_continue; }
 
2443
        -re ".* 909      12345678" { set x [expr $x+1]; exp_continue; }
 
2444
        -re ".* 909      1340" { set x [expr $x+1]; exp_continue; }
 
2445
        -re ".* 910 17ea 01756E28" { set x [expr $x+1]; exp_continue; }
 
2446
        -re ".* 910      12341340" { set x [expr $x+1]; exp_continue; }
 
2447
        -re ".* 911 17f2 01766E28" { set x [expr $x+1]; exp_continue; }
 
2448
        -re ".* 911      12341340" { set x [expr $x+1]; exp_continue; }
 
2449
        -re ".* 912 17fa 01776E28" { set x [expr $x+1]; exp_continue; }
 
2450
        -re ".* 912      12341340" { set x [expr $x+1]; exp_continue; }
 
2451
        -re ".* 913 1802 78256A28" { set x [expr $x+1]; exp_continue; }
 
2452
        -re ".* 913      12345678" { set x [expr $x+1]; exp_continue; }
 
2453
        -re ".* 913      1340" { set x [expr $x+1]; exp_continue; }
 
2454
        -re ".* 914 180c 78266A28" { set x [expr $x+1]; exp_continue; }
 
2455
        -re ".* 914      12345678" { set x [expr $x+1]; exp_continue; }
 
2456
        -re ".* 914      1340" { set x [expr $x+1]; exp_continue; }
 
2457
        -re ".* 915 1816 78276A28" { set x [expr $x+1]; exp_continue; }
 
2458
        -re ".* 915      12345678" { set x [expr $x+1]; exp_continue; }
 
2459
        -re ".* 915      1340" { set x [expr $x+1]; exp_continue; }
 
2460
        -re ".* 916 1820 7F121340" { set x [expr $x+1]; exp_continue; }
 
2461
        -re ".* 917 1824 6A181234" { set x [expr $x+1]; exp_continue; }
 
2462
        -re ".* 917      1340" { set x [expr $x+1]; exp_continue; }
 
2463
        -re ".* 918 182a 6A381234" { set x [expr $x+1]; exp_continue; }
 
2464
        -re ".* 918      56781340" { set x [expr $x+1]; exp_continue; }
 
2465
        -re ".* 919              " {
 
2466
            if [expr $x == 37] then {
 
2467
                pass "$testname: rotxr.b #2, ..."
 
2468
            } else {
 
2469
                fail "$testname: rotxr.b #2, ... ($x)"
 
2470
            }
 
2471
        }
 
2472
        default { fail "$testname: rotxr.b #2, ... ($x)" }
 
2473
    }
 
2474
 
 
2475
    set x 0
 
2476
    expect {
 
2477
        -re ".* 920 1832 1351" { set x [expr $x+1]; exp_continue; }
 
2478
        -re ".* 921 1834 7D901350" { set x [expr $x+1]; exp_continue; }
 
2479
        -re ".* 922 1838 01576918" { set x [expr $x+1]; exp_continue; }
 
2480
        -re ".* 922      1350" { set x [expr $x+1]; exp_continue; }
 
2481
        -re ".* 923 183e 01546D18" { set x [expr $x+1]; exp_continue; }
 
2482
        -re ".* 923      1350" { set x [expr $x+1]; exp_continue; }
 
2483
        -re ".* 924 1844 01576D18" { set x [expr $x+1]; exp_continue; }
 
2484
        -re ".* 924      1350" { set x [expr $x+1]; exp_continue; }
 
2485
        -re ".* 925 184a 01556D18" { set x [expr $x+1]; exp_continue; }
 
2486
        -re ".* 925      1350" { set x [expr $x+1]; exp_continue; }
 
2487
        -re ".* 926 1850 01566D18" { set x [expr $x+1]; exp_continue; }
 
2488
        -re ".* 926      1350" { set x [expr $x+1]; exp_continue; }
 
2489
        -re ".* 927 1856 01546F18" { set x [expr $x+1]; exp_continue; }
 
2490
        -re ".* 927      12341350" { set x [expr $x+1]; exp_continue; }
 
2491
        -re ".* 928 185e 78146B28" { set x [expr $x+1]; exp_continue; }
 
2492
        -re ".* 928      12345678" { set x [expr $x+1]; exp_continue; }
 
2493
        -re ".* 928      1350" { set x [expr $x+1]; exp_continue; }
 
2494
        -re ".* 929 1868 01556F28" { set x [expr $x+1]; exp_continue; }
 
2495
        -re ".* 929      12341350" { set x [expr $x+1]; exp_continue; }
 
2496
        -re ".* 930 1870 01566F28" { set x [expr $x+1]; exp_continue; }
 
2497
        -re ".* 930      12341350" { set x [expr $x+1]; exp_continue; }
 
2498
        -re ".* 931 1878 01576F28" { set x [expr $x+1]; exp_continue; }
 
2499
        -re ".* 931      12341350" { set x [expr $x+1]; exp_continue; }
 
2500
        -re ".* 932 1880 78256B28" { set x [expr $x+1]; exp_continue; }
 
2501
        -re ".* 932      12345678" { set x [expr $x+1]; exp_continue; }
 
2502
        -re ".* 932      1350" { set x [expr $x+1]; exp_continue; }
 
2503
        -re ".* 933 188a 78266B28" { set x [expr $x+1]; exp_continue; }
 
2504
        -re ".* 933      12345678" { set x [expr $x+1]; exp_continue; }
 
2505
        -re ".* 933      1350" { set x [expr $x+1]; exp_continue; }
 
2506
        -re ".* 934 1894 78276B28" { set x [expr $x+1]; exp_continue; }
 
2507
        -re ".* 934      12345678" { set x [expr $x+1]; exp_continue; }
 
2508
        -re ".* 934      1350" { set x [expr $x+1]; exp_continue; }
 
2509
        -re ".* 935 189e 6B181234" { set x [expr $x+1]; exp_continue; }
 
2510
        -re ".* 935      1350" { set x [expr $x+1]; exp_continue; }
 
2511
        -re ".* 936 18a4 6B381234" { set x [expr $x+1]; exp_continue; }
 
2512
        -re ".* 936      56781350" { set x [expr $x+1]; exp_continue; }
 
2513
        -re ".* 937              " {
 
2514
            if [expr $x == 36] then {
 
2515
                pass "$testname: rotxr.w #2, ..."
 
2516
            } else {
 
2517
                fail "$testname: rotxr.w #2, ... ($x)"
 
2518
            }
 
2519
        }
 
2520
        default { fail "$testname: rotxr.w #2, ... ($x)" }
 
2521
    }
 
2522
 
 
2523
    set x 0
 
2524
    expect {
 
2525
        -re ".* 938 18ac 1371" { set x [expr $x+1]; exp_continue; }
 
2526
        -re ".* 939 18ae 01046918" { set x [expr $x+1]; exp_continue; }
 
2527
        -re ".* 939      1370" { set x [expr $x+1]; exp_continue; }
 
2528
        -re ".* 940 18b4 01076918" { set x [expr $x+1]; exp_continue; }
 
2529
        -re ".* 940      1370" { set x [expr $x+1]; exp_continue; }
 
2530
        -re ".* 941 18ba 01046D18" { set x [expr $x+1]; exp_continue; }
 
2531
        -re ".* 941      1370" { set x [expr $x+1]; exp_continue; }
 
2532
        -re ".* 942 18c0 01076D18" { set x [expr $x+1]; exp_continue; }
 
2533
        -re ".* 942      1370" { set x [expr $x+1]; exp_continue; }
 
2534
        -re ".* 943 18c6 01056D18" { set x [expr $x+1]; exp_continue; }
 
2535
        -re ".* 943      1370" { set x [expr $x+1]; exp_continue; }
 
2536
        -re ".* 944 18cc 01066D18" { set x [expr $x+1]; exp_continue; }
 
2537
        -re ".* 944      1370" { set x [expr $x+1]; exp_continue; }
 
2538
        -re ".* 945 18d2 01046F18" { set x [expr $x+1]; exp_continue; }
 
2539
        -re ".* 945      12341370" { set x [expr $x+1]; exp_continue; }
 
2540
        -re ".* 946 18da 78946B28" { set x [expr $x+1]; exp_continue; }
 
2541
        -re ".* 946      12345678" { set x [expr $x+1]; exp_continue; }
 
2542
        -re ".* 946      1370" { set x [expr $x+1]; exp_continue; }
 
2543
        -re ".* 947 18e4 01056F28" { set x [expr $x+1]; exp_continue; }
 
2544
        -re ".* 947      12341370" { set x [expr $x+1]; exp_continue; }
 
2545
        -re ".* 948 18ec 01066F28" { set x [expr $x+1]; exp_continue; }
 
2546
        -re ".* 948      12341370" { set x [expr $x+1]; exp_continue; }
 
2547
        -re ".* 949 18f4 01076F28" { set x [expr $x+1]; exp_continue; }
 
2548
        -re ".* 949      12341370" { set x [expr $x+1]; exp_continue; }
 
2549
        -re ".* 950 18fc 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2550
        -re ".* 950      12345678" { set x [expr $x+1]; exp_continue; }
 
2551
        -re ".* 950      1370" { set x [expr $x+1]; exp_continue; }
 
2552
        -re ".* 951 1906 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2553
        -re ".* 951      12345678" { set x [expr $x+1]; exp_continue; }
 
2554
        -re ".* 951      1370" { set x [expr $x+1]; exp_continue; }
 
2555
        -re ".* 952 1910 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2556
        -re ".* 952      12345678" { set x [expr $x+1]; exp_continue; }
 
2557
        -re ".* 952      1370" { set x [expr $x+1]; exp_continue; }
 
2558
        -re ".* 953 191a 01046B08" { set x [expr $x+1]; exp_continue; }
 
2559
        -re ".* 953      12341370" { set x [expr $x+1]; exp_continue; }
 
2560
        -re ".* 954 1922 01046B28" { set x [expr $x+1]; exp_continue; }
 
2561
        -re ".* 954      12345678" { set x [expr $x+1]; exp_continue; }
 
2562
        -re ".* 954      1370" { set x [expr $x+1]; exp_continue; }
 
2563
        -re ".* 955              " {
 
2564
            if [expr $x == 38] then {
 
2565
                pass "$testname: rotxr.l #2, ..."
 
2566
            } else {
 
2567
                fail "$testname: rotxr.l #2, ... ($x)"
 
2568
            }
 
2569
        }
 
2570
        default { fail "$testname: rotxr.l #2, ... ($x)" }
 
2571
    }
 
2572
 
 
2573
    set x 0
 
2574
    expect {
 
2575
        -re ".* 956 192c 1281" { set x [expr $x+1]; exp_continue; }
 
2576
        -re ".* 957 192e 7D101280" { set x [expr $x+1]; exp_continue; }
 
2577
        -re ".* 958 1932 01776818" { set x [expr $x+1]; exp_continue; }
 
2578
        -re ".* 958      1280" { set x [expr $x+1]; exp_continue; }
 
2579
        -re ".* 959 1938 01746C18" { set x [expr $x+1]; exp_continue; }
 
2580
        -re ".* 959      1280" { set x [expr $x+1]; exp_continue; }
 
2581
        -re ".* 960 193e 01776C18" { set x [expr $x+1]; exp_continue; }
 
2582
        -re ".* 960      1280" { set x [expr $x+1]; exp_continue; }
 
2583
        -re ".* 961 1944 01756C18" { set x [expr $x+1]; exp_continue; }
 
2584
        -re ".* 961      1280" { set x [expr $x+1]; exp_continue; }
 
2585
        -re ".* 962 194a 01766C18" { set x [expr $x+1]; exp_continue; }
 
2586
        -re ".* 962      1280" { set x [expr $x+1]; exp_continue; }
 
2587
        -re ".* 963 1950 01746E18" { set x [expr $x+1]; exp_continue; }
 
2588
        -re ".* 963      12341280" { set x [expr $x+1]; exp_continue; }
 
2589
        -re ".* 964 1958 78146A28" { set x [expr $x+1]; exp_continue; }
 
2590
        -re ".* 964      12345678" { set x [expr $x+1]; exp_continue; }
 
2591
        -re ".* 964      1280" { set x [expr $x+1]; exp_continue; }
 
2592
        -re ".* 965 1962 01756E28" { set x [expr $x+1]; exp_continue; }
 
2593
        -re ".* 965      12341280" { set x [expr $x+1]; exp_continue; }
 
2594
        -re ".* 966 196a 01766E28" { set x [expr $x+1]; exp_continue; }
 
2595
        -re ".* 966      12341280" { set x [expr $x+1]; exp_continue; }
 
2596
        -re ".* 967 1972 01776E28" { set x [expr $x+1]; exp_continue; }
 
2597
        -re ".* 967      12341280" { set x [expr $x+1]; exp_continue; }
 
2598
        -re ".* 968 197a 78256A28" { set x [expr $x+1]; exp_continue; }
 
2599
        -re ".* 968      12345678" { set x [expr $x+1]; exp_continue; }
 
2600
        -re ".* 968      1280" { set x [expr $x+1]; exp_continue; }
 
2601
        -re ".* 969 1984 78266A28" { set x [expr $x+1]; exp_continue; }
 
2602
        -re ".* 969      12345678" { set x [expr $x+1]; exp_continue; }
 
2603
        -re ".* 969      1280" { set x [expr $x+1]; exp_continue; }
 
2604
        -re ".* 970 198e 78276A28" { set x [expr $x+1]; exp_continue; }
 
2605
        -re ".* 970      12345678" { set x [expr $x+1]; exp_continue; }
 
2606
        -re ".* 970      1280" { set x [expr $x+1]; exp_continue; }
 
2607
        -re ".* 971 1998 7F121280" { set x [expr $x+1]; exp_continue; }
 
2608
        -re ".* 972 199c 6A181234" { set x [expr $x+1]; exp_continue; }
 
2609
        -re ".* 972      1280" { set x [expr $x+1]; exp_continue; }
 
2610
        -re ".* 973 19a2 6A381234" { set x [expr $x+1]; exp_continue; }
 
2611
        -re ".* 973      56781280" { set x [expr $x+1]; exp_continue; }
 
2612
        -re ".* 974              " {
 
2613
            if [expr $x == 37] then {
 
2614
                pass "$testname: rotl.b ..."
 
2615
            } else {
 
2616
                fail "$testname: rotl.b ... ($x)"
 
2617
            }
 
2618
        }
 
2619
        default { fail "$testname: rotl.b ... ($x)" }
 
2620
    }
 
2621
 
 
2622
    set x 0
 
2623
    expect {
 
2624
        -re ".* 975 19aa 1291" { set x [expr $x+1]; exp_continue; }
 
2625
        -re ".* 976 19ac 7D901290" { set x [expr $x+1]; exp_continue; }
 
2626
        -re ".* 977 19b0 01576918" { set x [expr $x+1]; exp_continue; }
 
2627
        -re ".* 977      1290" { set x [expr $x+1]; exp_continue; }
 
2628
        -re ".* 978 19b6 01576D18" { set x [expr $x+1]; exp_continue; }
 
2629
        -re ".* 978      1290" { set x [expr $x+1]; exp_continue; }
 
2630
        -re ".* 979 19bc 01546D18" { set x [expr $x+1]; exp_continue; }
 
2631
        -re ".* 979      1290" { set x [expr $x+1]; exp_continue; }
 
2632
        -re ".* 980 19c2 01566D18" { set x [expr $x+1]; exp_continue; }
 
2633
        -re ".* 980      1290" { set x [expr $x+1]; exp_continue; }
 
2634
        -re ".* 981 19c8 01556D18" { set x [expr $x+1]; exp_continue; }
 
2635
        -re ".* 981      1290" { set x [expr $x+1]; exp_continue; }
 
2636
        -re ".* 982 19ce 01546F18" { set x [expr $x+1]; exp_continue; }
 
2637
        -re ".* 982      12341290" { set x [expr $x+1]; exp_continue; }
 
2638
        -re ".* 983 19d6 78146B28" { set x [expr $x+1]; exp_continue; }
 
2639
        -re ".* 983      12345678" { set x [expr $x+1]; exp_continue; }
 
2640
        -re ".* 983      1290" { set x [expr $x+1]; exp_continue; }
 
2641
        -re ".* 984 19e0 01556F28" { set x [expr $x+1]; exp_continue; }
 
2642
        -re ".* 984      12341290" { set x [expr $x+1]; exp_continue; }
 
2643
        -re ".* 985 19e8 01566F28" { set x [expr $x+1]; exp_continue; }
 
2644
        -re ".* 985      12341290" { set x [expr $x+1]; exp_continue; }
 
2645
        -re ".* 986 19f0 01576F28" { set x [expr $x+1]; exp_continue; }
 
2646
        -re ".* 986      12341290" { set x [expr $x+1]; exp_continue; }
 
2647
        -re ".* 987 19f8 78256B28" { set x [expr $x+1]; exp_continue; }
 
2648
        -re ".* 987      12345678" { set x [expr $x+1]; exp_continue; }
 
2649
        -re ".* 987      1290" { set x [expr $x+1]; exp_continue; }
 
2650
        -re ".* 988 1a02 78266B28" { set x [expr $x+1]; exp_continue; }
 
2651
        -re ".* 988      12345678" { set x [expr $x+1]; exp_continue; }
 
2652
        -re ".* 988      1290" { set x [expr $x+1]; exp_continue; }
 
2653
        -re ".* 989 1a0c 78276B28" { set x [expr $x+1]; exp_continue; }
 
2654
        -re ".* 989      12345678" { set x [expr $x+1]; exp_continue; }
 
2655
        -re ".* 989      1290" { set x [expr $x+1]; exp_continue; }
 
2656
        -re ".* 990 1a16 6B181234" { set x [expr $x+1]; exp_continue; }
 
2657
        -re ".* 990      1290" { set x [expr $x+1]; exp_continue; }
 
2658
        -re ".* 991 1a1c 6B381234" { set x [expr $x+1]; exp_continue; }
 
2659
        -re ".* 991      56781290" { set x [expr $x+1]; exp_continue; }
 
2660
        -re ".* 992              " {
 
2661
            if [expr $x == 36] then {
 
2662
                pass "$testname: rotl.w ..."
 
2663
            } else {
 
2664
                fail "$testname: rotl.w ... ($x)"
 
2665
            }
 
2666
        }
 
2667
        default { fail "$testname: rotl.w ... ($x)" }
 
2668
    }
 
2669
 
 
2670
    set x 0
 
2671
    expect {
 
2672
        -re ".* 993 1a24 12B1" { set x [expr $x+1]; exp_continue; }
 
2673
        -re ".* 994 1a26 01046918" { set x [expr $x+1]; exp_continue; }
 
2674
        -re ".* 994      12B0" { set x [expr $x+1]; exp_continue; }
 
2675
        -re ".* 995 1a2c 01076918" { set x [expr $x+1]; exp_continue; }
 
2676
        -re ".* 995      12B0" { set x [expr $x+1]; exp_continue; }
 
2677
        -re ".* 996 1a32 01046D18" { set x [expr $x+1]; exp_continue; }
 
2678
        -re ".* 996      12B0" { set x [expr $x+1]; exp_continue; }
 
2679
        -re ".* 997 1a38 01076D18" { set x [expr $x+1]; exp_continue; }
 
2680
        -re ".* 997      12B0" { set x [expr $x+1]; exp_continue; }
 
2681
        -re ".* 998 1a3e 01056D18" { set x [expr $x+1]; exp_continue; }
 
2682
        -re ".* 998      12B0" { set x [expr $x+1]; exp_continue; }
 
2683
        -re ".* 999 1a44 01066D18" { set x [expr $x+1]; exp_continue; }
 
2684
        -re ".* 999      12B0" { set x [expr $x+1]; exp_continue; }
 
2685
        -re ".* 1000 1a4a 01046F18" { set x [expr $x+1]; exp_continue; }
 
2686
        -re ".* 1000      123412B0" { set x [expr $x+1]; exp_continue; }
 
2687
        -re ".* 1001 1a52 78946B28" { set x [expr $x+1]; exp_continue; }
 
2688
        -re ".* 1001      12345678" { set x [expr $x+1]; exp_continue; }
 
2689
        -re ".* 1001      12B0" { set x [expr $x+1]; exp_continue; }
 
2690
        -re ".* 1002 1a5c 01056F28" { set x [expr $x+1]; exp_continue; }
 
2691
        -re ".* 1002      123412B0" { set x [expr $x+1]; exp_continue; }
 
2692
        -re ".* 1003 1a64 01066F28" { set x [expr $x+1]; exp_continue; }
 
2693
        -re ".* 1003      123412B0" { set x [expr $x+1]; exp_continue; }
 
2694
        -re ".* 1004 1a6c 01076F28" { set x [expr $x+1]; exp_continue; }
 
2695
        -re ".* 1004      123412B0" { set x [expr $x+1]; exp_continue; }
 
2696
        -re ".* 1005 1a74 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2697
        -re ".* 1005      12345678" { set x [expr $x+1]; exp_continue; }
 
2698
        -re ".* 1005      12B0" { set x [expr $x+1]; exp_continue; }
 
2699
        -re ".* 1006 1a7e 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2700
        -re ".* 1006      12345678" { set x [expr $x+1]; exp_continue; }
 
2701
        -re ".* 1006      12B0" { set x [expr $x+1]; exp_continue; }
 
2702
        -re ".* 1007 1a88 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2703
        -re ".* 1007      12345678" { set x [expr $x+1]; exp_continue; }
 
2704
        -re ".* 1007      12B0" { set x [expr $x+1]; exp_continue; }
 
2705
        -re ".* 1008 1a92 01046B08" { set x [expr $x+1]; exp_continue; }
 
2706
        -re ".* 1008      123412B0" { set x [expr $x+1]; exp_continue; }
 
2707
        -re ".* 1009 1a9a 01046B28" { set x [expr $x+1]; exp_continue; }
 
2708
        -re ".* 1009      12345678" { set x [expr $x+1]; exp_continue; }
 
2709
        -re ".* 1009      12B0" { set x [expr $x+1]; exp_continue; }
 
2710
        -re ".* 1010             " {
 
2711
            if [expr $x == 38] then {
 
2712
                pass "$testname: rotl.l ..."
 
2713
            } else {
 
2714
                fail "$testname: rotl.l ... ($x)"
 
2715
            }
 
2716
        }
 
2717
        default { fail "$testname: rotl.l ... ($x)" }
 
2718
    }
 
2719
 
 
2720
    set x 0
 
2721
    expect {
 
2722
        -re ".* 1011 1aa4 12C1" { set x [expr $x+1]; exp_continue; }
 
2723
        -re ".* 1012 1aa6 7D1012C0" { set x [expr $x+1]; exp_continue; }
 
2724
        -re ".* 1013 1aaa 01776818" { set x [expr $x+1]; exp_continue; }
 
2725
        -re ".* 1013      12C0" { set x [expr $x+1]; exp_continue; }
 
2726
        -re ".* 1014 1ab0 01746C18" { set x [expr $x+1]; exp_continue; }
 
2727
        -re ".* 1014      12C0" { set x [expr $x+1]; exp_continue; }
 
2728
        -re ".* 1015 1ab6 01776C18" { set x [expr $x+1]; exp_continue; }
 
2729
        -re ".* 1015      12C0" { set x [expr $x+1]; exp_continue; }
 
2730
        -re ".* 1016 1abc 01756C18" { set x [expr $x+1]; exp_continue; }
 
2731
        -re ".* 1016      12C0" { set x [expr $x+1]; exp_continue; }
 
2732
        -re ".* 1017 1ac2 01766C18" { set x [expr $x+1]; exp_continue; }
 
2733
        -re ".* 1017      12C0" { set x [expr $x+1]; exp_continue; }
 
2734
        -re ".* 1018 1ac8 01746E18" { set x [expr $x+1]; exp_continue; }
 
2735
        -re ".* 1018      123412C0" { set x [expr $x+1]; exp_continue; }
 
2736
        -re ".* 1019 1ad0 78146A28" { set x [expr $x+1]; exp_continue; }
 
2737
        -re ".* 1019      12345678" { set x [expr $x+1]; exp_continue; }
 
2738
        -re ".* 1019      12C0" { set x [expr $x+1]; exp_continue; }
 
2739
        -re ".* 1020 1ada 01756E28" { set x [expr $x+1]; exp_continue; }
 
2740
        -re ".* 1020      123412C0" { set x [expr $x+1]; exp_continue; }
 
2741
        -re ".* 1021 1ae2 01766E28" { set x [expr $x+1]; exp_continue; }
 
2742
        -re ".* 1021      123412C0" { set x [expr $x+1]; exp_continue; }
 
2743
        -re ".* 1022 1aea 01776E28" { set x [expr $x+1]; exp_continue; }
 
2744
        -re ".* 1022      123412C0" { set x [expr $x+1]; exp_continue; }
 
2745
        -re ".* 1023 1af2 78256A28" { set x [expr $x+1]; exp_continue; }
 
2746
        -re ".* 1023      12345678" { set x [expr $x+1]; exp_continue; }
 
2747
        -re ".* 1023      12C0" { set x [expr $x+1]; exp_continue; }
 
2748
        -re ".* 1024 1afc 78266A28" { set x [expr $x+1]; exp_continue; }
 
2749
        -re ".* 1024      12345678" { set x [expr $x+1]; exp_continue; }
 
2750
        -re ".* 1024      12C0" { set x [expr $x+1]; exp_continue; }
 
2751
        -re ".* 1025 1b06 78276A28" { set x [expr $x+1]; exp_continue; }
 
2752
        -re ".* 1025      12345678" { set x [expr $x+1]; exp_continue; }
 
2753
        -re ".* 1025      12C0" { set x [expr $x+1]; exp_continue; }
 
2754
        -re ".* 1026 1b10 7F1212C0" { set x [expr $x+1]; exp_continue; }
 
2755
        -re ".* 1027 1b14 6A181234" { set x [expr $x+1]; exp_continue; }
 
2756
        -re ".* 1027      12C0" { set x [expr $x+1]; exp_continue; }
 
2757
        -re ".* 1028 1b1a 6A381234" { set x [expr $x+1]; exp_continue; }
 
2758
        -re ".* 1028      567812C0" { set x [expr $x+1]; exp_continue; }
 
2759
        -re ".* 1029             " {
 
2760
            if [expr $x == 37] then {
 
2761
                pass "$testname: rotl.b #2, ..."
 
2762
            } else {
 
2763
                fail "$testname: rotl.b #2, ... ($x)"
 
2764
            }
 
2765
        }
 
2766
        default { fail "$testname: rotl.b #2, ... ($x)" }
 
2767
    }
 
2768
 
 
2769
    set x 0
 
2770
    expect {
 
2771
        -re ".* 1030 1b22 12D1" { set x [expr $x+1]; exp_continue; }
 
2772
        -re ".* 1031 1b24 7D9012D0" { set x [expr $x+1]; exp_continue; }
 
2773
        -re ".* 1032 1b28 01576918" { set x [expr $x+1]; exp_continue; }
 
2774
        -re ".* 1032      12D0" { set x [expr $x+1]; exp_continue; }
 
2775
        -re ".* 1033 1b2e 01546D18" { set x [expr $x+1]; exp_continue; }
 
2776
        -re ".* 1033      12D0" { set x [expr $x+1]; exp_continue; }
 
2777
        -re ".* 1034 1b34 01576D18" { set x [expr $x+1]; exp_continue; }
 
2778
        -re ".* 1034      12D0" { set x [expr $x+1]; exp_continue; }
 
2779
        -re ".* 1035 1b3a 01556D18" { set x [expr $x+1]; exp_continue; }
 
2780
        -re ".* 1035      12D0" { set x [expr $x+1]; exp_continue; }
 
2781
        -re ".* 1036 1b40 01566D18" { set x [expr $x+1]; exp_continue; }
 
2782
        -re ".* 1036      12D0" { set x [expr $x+1]; exp_continue; }
 
2783
        -re ".* 1037 1b46 01546F18" { set x [expr $x+1]; exp_continue; }
 
2784
        -re ".* 1037      123412D0" { set x [expr $x+1]; exp_continue; }
 
2785
        -re ".* 1038 1b4e 78146B28" { set x [expr $x+1]; exp_continue; }
 
2786
        -re ".* 1038      12345678" { set x [expr $x+1]; exp_continue; }
 
2787
        -re ".* 1038      12D0" { set x [expr $x+1]; exp_continue; }
 
2788
        -re ".* 1039 1b58 01556F28" { set x [expr $x+1]; exp_continue; }
 
2789
        -re ".* 1039      123412D0" { set x [expr $x+1]; exp_continue; }
 
2790
        -re ".* 1040 1b60 01566F28" { set x [expr $x+1]; exp_continue; }
 
2791
        -re ".* 1040      123412D0" { set x [expr $x+1]; exp_continue; }
 
2792
        -re ".* 1041 1b68 01576F28" { set x [expr $x+1]; exp_continue; }
 
2793
        -re ".* 1041      123412D0" { set x [expr $x+1]; exp_continue; }
 
2794
        -re ".* 1042 1b70 78256B28" { set x [expr $x+1]; exp_continue; }
 
2795
        -re ".* 1042      12345678" { set x [expr $x+1]; exp_continue; }
 
2796
        -re ".* 1042      12D0" { set x [expr $x+1]; exp_continue; }
 
2797
        -re ".* 1043 1b7a 78266B28" { set x [expr $x+1]; exp_continue; }
 
2798
        -re ".* 1043      12345678" { set x [expr $x+1]; exp_continue; }
 
2799
        -re ".* 1043      12D0" { set x [expr $x+1]; exp_continue; }
 
2800
        -re ".* 1044 1b84 78276B28" { set x [expr $x+1]; exp_continue; }
 
2801
        -re ".* 1044      12345678" { set x [expr $x+1]; exp_continue; }
 
2802
        -re ".* 1044      12D0" { set x [expr $x+1]; exp_continue; }
 
2803
        -re ".* 1045 1b8e 6B181234" { set x [expr $x+1]; exp_continue; }
 
2804
        -re ".* 1045      12D0" { set x [expr $x+1]; exp_continue; }
 
2805
        -re ".* 1046 1b94 6B381234" { set x [expr $x+1]; exp_continue; }
 
2806
        -re ".* 1046      567812D0" { set x [expr $x+1]; exp_continue; }
 
2807
        -re ".* 1047             " {
 
2808
            if [expr $x == 36] then {
 
2809
                pass "$testname: rotl.w #2, ..."
 
2810
            } else {
 
2811
                fail "$testname: rotl.w #2, ... ($x)"
 
2812
            }
 
2813
        }
 
2814
        default { fail "$testname: rotl.w #2, ... ($x)" }
 
2815
    }
 
2816
 
 
2817
    set x 0
 
2818
    expect {
 
2819
        -re ".* 1048 1b9c 12F1" { set x [expr $x+1]; exp_continue; }
 
2820
        -re ".* 1049 1b9e 01046918" { set x [expr $x+1]; exp_continue; }
 
2821
        -re ".* 1049      12F0" { set x [expr $x+1]; exp_continue; }
 
2822
        -re ".* 1050 1ba4 01076918" { set x [expr $x+1]; exp_continue; }
 
2823
        -re ".* 1050      12F0" { set x [expr $x+1]; exp_continue; }
 
2824
        -re ".* 1051 1baa 01046D18" { set x [expr $x+1]; exp_continue; }
 
2825
        -re ".* 1051      12F0" { set x [expr $x+1]; exp_continue; }
 
2826
        -re ".* 1052 1bb0 01076D18" { set x [expr $x+1]; exp_continue; }
 
2827
        -re ".* 1052      12F0" { set x [expr $x+1]; exp_continue; }
 
2828
        -re ".* 1053 1bb6 01056D18" { set x [expr $x+1]; exp_continue; }
 
2829
        -re ".* 1053      12F0" { set x [expr $x+1]; exp_continue; }
 
2830
        -re ".* 1054 1bbc 01066D18" { set x [expr $x+1]; exp_continue; }
 
2831
        -re ".* 1054      12F0" { set x [expr $x+1]; exp_continue; }
 
2832
        -re ".* 1055 1bc2 01046F18" { set x [expr $x+1]; exp_continue; }
 
2833
        -re ".* 1055      123412F0" { set x [expr $x+1]; exp_continue; }
 
2834
        -re ".* 1056 1bca 78946B28" { set x [expr $x+1]; exp_continue; }
 
2835
        -re ".* 1056      12345678" { set x [expr $x+1]; exp_continue; }
 
2836
        -re ".* 1056      12F0" { set x [expr $x+1]; exp_continue; }
 
2837
        -re ".* 1057 1bd4 01056F28" { set x [expr $x+1]; exp_continue; }
 
2838
        -re ".* 1057      123412F0" { set x [expr $x+1]; exp_continue; }
 
2839
        -re ".* 1058 1bdc 01066F28" { set x [expr $x+1]; exp_continue; }
 
2840
        -re ".* 1058      123412F0" { set x [expr $x+1]; exp_continue; }
 
2841
        -re ".* 1059 1be4 01076F28" { set x [expr $x+1]; exp_continue; }
 
2842
        -re ".* 1059      123412F0" { set x [expr $x+1]; exp_continue; }
 
2843
        -re ".* 1060 1bec 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2844
        -re ".* 1060      12345678" { set x [expr $x+1]; exp_continue; }
 
2845
        -re ".* 1060      12F0" { set x [expr $x+1]; exp_continue; }
 
2846
        -re ".* 1061 1bf6 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2847
        -re ".* 1061      12345678" { set x [expr $x+1]; exp_continue; }
 
2848
        -re ".* 1061      12F0" { set x [expr $x+1]; exp_continue; }
 
2849
        -re ".* 1062 1c00 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2850
        -re ".* 1062      12345678" { set x [expr $x+1]; exp_continue; }
 
2851
        -re ".* 1062      12F0" { set x [expr $x+1]; exp_continue; }
 
2852
        -re ".* 1063 1c0a 01046B08" { set x [expr $x+1]; exp_continue; }
 
2853
        -re ".* 1063      123412F0" { set x [expr $x+1]; exp_continue; }
 
2854
        -re ".* 1064 1c12 01046B28" { set x [expr $x+1]; exp_continue; }
 
2855
        -re ".* 1064      12345678" { set x [expr $x+1]; exp_continue; }
 
2856
        -re ".* 1064      12F0" { set x [expr $x+1]; exp_continue; }
 
2857
        -re ".* 1065             " {
 
2858
            if [expr $x == 38] then {
 
2859
                pass "$testname: rotl.l #2, ..."
 
2860
            } else {
 
2861
                fail "$testname: rotl.l #2, ... ($x)"
 
2862
            }
 
2863
        }
 
2864
        default { fail "$testname: rotl.l #2, ... ($x)" }
 
2865
    }
 
2866
 
 
2867
    set x 0
 
2868
    expect {
 
2869
        -re ".* 1066 1c1c 1381" { set x [expr $x+1]; exp_continue; }
 
2870
        -re ".* 1067 1c1e 7D101380" { set x [expr $x+1]; exp_continue; }
 
2871
        -re ".* 1068 1c22 01776818" { set x [expr $x+1]; exp_continue; }
 
2872
        -re ".* 1068      1380" { set x [expr $x+1]; exp_continue; }
 
2873
        -re ".* 1069 1c28 01746C18" { set x [expr $x+1]; exp_continue; }
 
2874
        -re ".* 1069      1380" { set x [expr $x+1]; exp_continue; }
 
2875
        -re ".* 1070 1c2e 01776C18" { set x [expr $x+1]; exp_continue; }
 
2876
        -re ".* 1070      1380" { set x [expr $x+1]; exp_continue; }
 
2877
        -re ".* 1071 1c34 01756C18" { set x [expr $x+1]; exp_continue; }
 
2878
        -re ".* 1071      1380" { set x [expr $x+1]; exp_continue; }
 
2879
        -re ".* 1072 1c3a 01766C18" { set x [expr $x+1]; exp_continue; }
 
2880
        -re ".* 1072      1380" { set x [expr $x+1]; exp_continue; }
 
2881
        -re ".* 1073 1c40 01746E18" { set x [expr $x+1]; exp_continue; }
 
2882
        -re ".* 1073      12341380" { set x [expr $x+1]; exp_continue; }
 
2883
        -re ".* 1074 1c48 78146A28" { set x [expr $x+1]; exp_continue; }
 
2884
        -re ".* 1074      12345678" { set x [expr $x+1]; exp_continue; }
 
2885
        -re ".* 1074      1380" { set x [expr $x+1]; exp_continue; }
 
2886
        -re ".* 1075 1c52 01756E28" { set x [expr $x+1]; exp_continue; }
 
2887
        -re ".* 1075      12341380" { set x [expr $x+1]; exp_continue; }
 
2888
        -re ".* 1076 1c5a 01766E28" { set x [expr $x+1]; exp_continue; }
 
2889
        -re ".* 1076      12341380" { set x [expr $x+1]; exp_continue; }
 
2890
        -re ".* 1077 1c62 01776E28" { set x [expr $x+1]; exp_continue; }
 
2891
        -re ".* 1077      12341380" { set x [expr $x+1]; exp_continue; }
 
2892
        -re ".* 1078 1c6a 78256A28" { set x [expr $x+1]; exp_continue; }
 
2893
        -re ".* 1078      12345678" { set x [expr $x+1]; exp_continue; }
 
2894
        -re ".* 1078      1380" { set x [expr $x+1]; exp_continue; }
 
2895
        -re ".* 1079 1c74 78266A28" { set x [expr $x+1]; exp_continue; }
 
2896
        -re ".* 1079      12345678" { set x [expr $x+1]; exp_continue; }
 
2897
        -re ".* 1079      1380" { set x [expr $x+1]; exp_continue; }
 
2898
        -re ".* 1080 1c7e 78276A28" { set x [expr $x+1]; exp_continue; }
 
2899
        -re ".* 1080      12345678" { set x [expr $x+1]; exp_continue; }
 
2900
        -re ".* 1080      1380" { set x [expr $x+1]; exp_continue; }
 
2901
        -re ".* 1081 1c88 7F121380" { set x [expr $x+1]; exp_continue; }
 
2902
        -re ".* 1082 1c8c 6A181234" { set x [expr $x+1]; exp_continue; }
 
2903
        -re ".* 1082      1380" { set x [expr $x+1]; exp_continue; }
 
2904
        -re ".* 1083 1c92 6A381234" { set x [expr $x+1]; exp_continue; }
 
2905
        -re ".* 1083      56781380" { set x [expr $x+1]; exp_continue; }
 
2906
        -re ".* 1084             " {
 
2907
            if [expr $x == 37] then {
 
2908
                pass "$testname: rotr.b ..."
 
2909
            } else {
 
2910
                fail "$testname: rotr.b ... ($x)"
 
2911
            }
 
2912
        }
 
2913
        default { fail "$testname: rotr.b ... ($x)" }
 
2914
    }
 
2915
 
 
2916
    set x 0
 
2917
    expect {
 
2918
        -re ".* 1085 1c9a 1391" { set x [expr $x+1]; exp_continue; }
 
2919
        -re ".* 1086 1c9c 7D901390" { set x [expr $x+1]; exp_continue; }
 
2920
        -re ".* 1087 1ca0 01576918" { set x [expr $x+1]; exp_continue; }
 
2921
        -re ".* 1087      1390" { set x [expr $x+1]; exp_continue; }
 
2922
        -re ".* 1088 1ca6 01576D18" { set x [expr $x+1]; exp_continue; }
 
2923
        -re ".* 1088      1390" { set x [expr $x+1]; exp_continue; }
 
2924
        -re ".* 1089 1cac 01546D18" { set x [expr $x+1]; exp_continue; }
 
2925
        -re ".* 1089      1390" { set x [expr $x+1]; exp_continue; }
 
2926
        -re ".* 1090 1cb2 01566D18" { set x [expr $x+1]; exp_continue; }
 
2927
        -re ".* 1090      1390" { set x [expr $x+1]; exp_continue; }
 
2928
        -re ".* 1091 1cb8 01556D18" { set x [expr $x+1]; exp_continue; }
 
2929
        -re ".* 1091      1390" { set x [expr $x+1]; exp_continue; }
 
2930
        -re ".* 1092 1cbe 01546F18" { set x [expr $x+1]; exp_continue; }
 
2931
        -re ".* 1092      12341390" { set x [expr $x+1]; exp_continue; }
 
2932
        -re ".* 1093 1cc6 78146B28" { set x [expr $x+1]; exp_continue; }
 
2933
        -re ".* 1093      12345678" { set x [expr $x+1]; exp_continue; }
 
2934
        -re ".* 1093      1390" { set x [expr $x+1]; exp_continue; }
 
2935
        -re ".* 1094 1cd0 01556F28" { set x [expr $x+1]; exp_continue; }
 
2936
        -re ".* 1094      12341390" { set x [expr $x+1]; exp_continue; }
 
2937
        -re ".* 1095 1cd8 01566F28" { set x [expr $x+1]; exp_continue; }
 
2938
        -re ".* 1095      12341390" { set x [expr $x+1]; exp_continue; }
 
2939
        -re ".* 1096 1ce0 01576F28" { set x [expr $x+1]; exp_continue; }
 
2940
        -re ".* 1096      12341390" { set x [expr $x+1]; exp_continue; }
 
2941
        -re ".* 1097 1ce8 78256B28" { set x [expr $x+1]; exp_continue; }
 
2942
        -re ".* 1097      12345678" { set x [expr $x+1]; exp_continue; }
 
2943
        -re ".* 1097      1390" { set x [expr $x+1]; exp_continue; }
 
2944
        -re ".* 1098 1cf2 78266B28" { set x [expr $x+1]; exp_continue; }
 
2945
        -re ".* 1098      12345678" { set x [expr $x+1]; exp_continue; }
 
2946
        -re ".* 1098      1390" { set x [expr $x+1]; exp_continue; }
 
2947
        -re ".* 1099 1cfc 78276B28" { set x [expr $x+1]; exp_continue; }
 
2948
        -re ".* 1099      12345678" { set x [expr $x+1]; exp_continue; }
 
2949
        -re ".* 1099      1390" { set x [expr $x+1]; exp_continue; }
 
2950
        -re ".* 1100 1d06 6B181234" { set x [expr $x+1]; exp_continue; }
 
2951
        -re ".* 1100      1390" { set x [expr $x+1]; exp_continue; }
 
2952
        -re ".* 1101 1d0c 6B381234" { set x [expr $x+1]; exp_continue; }
 
2953
        -re ".* 1101      56781390" { set x [expr $x+1]; exp_continue; }
 
2954
        -re ".* 1102             " {
 
2955
            if [expr $x == 36] then {
 
2956
                pass "$testname: rotr.w ..."
 
2957
            } else {
 
2958
                fail "$testname: rotr.w ... ($x)"
 
2959
            }
 
2960
        }
 
2961
        default { fail "$testname: rotr.w ... ($x)" }
 
2962
    }
 
2963
 
 
2964
    set x 0
 
2965
    expect {
 
2966
        -re ".* 1103 1d14 13B1" { set x [expr $x+1]; exp_continue; }
 
2967
        -re ".* 1104 1d16 01046918" { set x [expr $x+1]; exp_continue; }
 
2968
        -re ".* 1104      13B0" { set x [expr $x+1]; exp_continue; }
 
2969
        -re ".* 1105 1d1c 01076918" { set x [expr $x+1]; exp_continue; }
 
2970
        -re ".* 1105      13B0" { set x [expr $x+1]; exp_continue; }
 
2971
        -re ".* 1106 1d22 01046D18" { set x [expr $x+1]; exp_continue; }
 
2972
        -re ".* 1106      13B0" { set x [expr $x+1]; exp_continue; }
 
2973
        -re ".* 1107 1d28 01076D18" { set x [expr $x+1]; exp_continue; }
 
2974
        -re ".* 1107      13B0" { set x [expr $x+1]; exp_continue; }
 
2975
        -re ".* 1108 1d2e 01056D18" { set x [expr $x+1]; exp_continue; }
 
2976
        -re ".* 1108      13B0" { set x [expr $x+1]; exp_continue; }
 
2977
        -re ".* 1109 1d34 01066D18" { set x [expr $x+1]; exp_continue; }
 
2978
        -re ".* 1109      13B0" { set x [expr $x+1]; exp_continue; }
 
2979
        -re ".* 1110 1d3a 01046F18" { set x [expr $x+1]; exp_continue; }
 
2980
        -re ".* 1110      123413B0" { set x [expr $x+1]; exp_continue; }
 
2981
        -re ".* 1111 1d42 78946B28" { set x [expr $x+1]; exp_continue; }
 
2982
        -re ".* 1111      12345678" { set x [expr $x+1]; exp_continue; }
 
2983
        -re ".* 1111      13B0" { set x [expr $x+1]; exp_continue; }
 
2984
        -re ".* 1112 1d4c 01056F28" { set x [expr $x+1]; exp_continue; }
 
2985
        -re ".* 1112      123413B0" { set x [expr $x+1]; exp_continue; }
 
2986
        -re ".* 1113 1d54 01066F28" { set x [expr $x+1]; exp_continue; }
 
2987
        -re ".* 1113      123413B0" { set x [expr $x+1]; exp_continue; }
 
2988
        -re ".* 1114 1d5c 01076F28" { set x [expr $x+1]; exp_continue; }
 
2989
        -re ".* 1114      123413B0" { set x [expr $x+1]; exp_continue; }
 
2990
        -re ".* 1115 1d64 78A56B28" { set x [expr $x+1]; exp_continue; }
 
2991
        -re ".* 1115      12345678" { set x [expr $x+1]; exp_continue; }
 
2992
        -re ".* 1115      13B0" { set x [expr $x+1]; exp_continue; }
 
2993
        -re ".* 1116 1d6e 78A66B28" { set x [expr $x+1]; exp_continue; }
 
2994
        -re ".* 1116      12345678" { set x [expr $x+1]; exp_continue; }
 
2995
        -re ".* 1116      13B0" { set x [expr $x+1]; exp_continue; }
 
2996
        -re ".* 1117 1d78 78A76B28" { set x [expr $x+1]; exp_continue; }
 
2997
        -re ".* 1117      12345678" { set x [expr $x+1]; exp_continue; }
 
2998
        -re ".* 1117      13B0" { set x [expr $x+1]; exp_continue; }
 
2999
        -re ".* 1118 1d82 01046B08" { set x [expr $x+1]; exp_continue; }
 
3000
        -re ".* 1118      123413B0" { set x [expr $x+1]; exp_continue; }
 
3001
        -re ".* 1119 1d8a 01046B28" { set x [expr $x+1]; exp_continue; }
 
3002
        -re ".* 1119      12345678" { set x [expr $x+1]; exp_continue; }
 
3003
        -re ".* 1119      13B0" { set x [expr $x+1]; exp_continue; }
 
3004
        -re ".* 1120             " {
 
3005
            if [expr $x == 38] then {
 
3006
                pass "$testname: rotr.l ..."
 
3007
            } else {
 
3008
                fail "$testname: rotr.l ... ($x)"
 
3009
            }
 
3010
        }
 
3011
        default { fail "$testname: rotr.l ... ($x)" }
 
3012
    }
 
3013
 
 
3014
    set x 0
 
3015
    expect {
 
3016
        -re ".* 1121 1d94 13C1" { set x [expr $x+1]; exp_continue; }
 
3017
        -re ".* 1122 1d96 7D1013C0" { set x [expr $x+1]; exp_continue; }
 
3018
        -re ".* 1123 1d9a 01776818" { set x [expr $x+1]; exp_continue; }
 
3019
        -re ".* 1123      13C0" { set x [expr $x+1]; exp_continue; }
 
3020
        -re ".* 1124 1da0 01746C18" { set x [expr $x+1]; exp_continue; }
 
3021
        -re ".* 1124      13C0" { set x [expr $x+1]; exp_continue; }
 
3022
        -re ".* 1125 1da6 01776C18" { set x [expr $x+1]; exp_continue; }
 
3023
        -re ".* 1125      13C0" { set x [expr $x+1]; exp_continue; }
 
3024
        -re ".* 1126 1dac 01756C18" { set x [expr $x+1]; exp_continue; }
 
3025
        -re ".* 1126      13C0" { set x [expr $x+1]; exp_continue; }
 
3026
        -re ".* 1127 1db2 01766C18" { set x [expr $x+1]; exp_continue; }
 
3027
        -re ".* 1127      13C0" { set x [expr $x+1]; exp_continue; }
 
3028
        -re ".* 1128 1db8 01746E18" { set x [expr $x+1]; exp_continue; }
 
3029
        -re ".* 1128      123413C0" { set x [expr $x+1]; exp_continue; }
 
3030
        -re ".* 1129 1dc0 78146A28" { set x [expr $x+1]; exp_continue; }
 
3031
        -re ".* 1129      12345678" { set x [expr $x+1]; exp_continue; }
 
3032
        -re ".* 1129      13C0" { set x [expr $x+1]; exp_continue; }
 
3033
        -re ".* 1130 1dca 01756E28" { set x [expr $x+1]; exp_continue; }
 
3034
        -re ".* 1130      123413C0" { set x [expr $x+1]; exp_continue; }
 
3035
        -re ".* 1131 1dd2 01766E28" { set x [expr $x+1]; exp_continue; }
 
3036
        -re ".* 1131      123413C0" { set x [expr $x+1]; exp_continue; }
 
3037
        -re ".* 1132 1dda 01776E28" { set x [expr $x+1]; exp_continue; }
 
3038
        -re ".* 1132      123413C0" { set x [expr $x+1]; exp_continue; }
 
3039
        -re ".* 1133 1de2 78256A28" { set x [expr $x+1]; exp_continue; }
 
3040
        -re ".* 1133      12345678" { set x [expr $x+1]; exp_continue; }
 
3041
        -re ".* 1133      13C0" { set x [expr $x+1]; exp_continue; }
 
3042
        -re ".* 1134 1dec 78266A28" { set x [expr $x+1]; exp_continue; }
 
3043
        -re ".* 1134      12345678" { set x [expr $x+1]; exp_continue; }
 
3044
        -re ".* 1134      13C0" { set x [expr $x+1]; exp_continue; }
 
3045
        -re ".* 1135 1df6 78276A28" { set x [expr $x+1]; exp_continue; }
 
3046
        -re ".* 1135      12345678" { set x [expr $x+1]; exp_continue; }
 
3047
        -re ".* 1135      13C0" { set x [expr $x+1]; exp_continue; }
 
3048
        -re ".* 1136 1e00 7F1213C0" { set x [expr $x+1]; exp_continue; }
 
3049
        -re ".* 1137 1e04 6A181234" { set x [expr $x+1]; exp_continue; }
 
3050
        -re ".* 1137      13C0" { set x [expr $x+1]; exp_continue; }
 
3051
        -re ".* 1138 1e0a 6A381234" { set x [expr $x+1]; exp_continue; }
 
3052
        -re ".* 1138      567813C0" { set x [expr $x+1]; exp_continue; }
 
3053
        -re ".* 1139             " {
 
3054
            if [expr $x == 37] then {
 
3055
                pass "$testname: rotr.b #2, ..."
 
3056
            } else {
 
3057
                fail "$testname: rotr.b #2, ... ($x)"
 
3058
            }
 
3059
        }
 
3060
        default { fail "$testname: rotr.b #2, ... ($x)" }
 
3061
    }
 
3062
 
 
3063
    set x 0
 
3064
    expect {
 
3065
        -re ".* 1140 1e12 13D1" { set x [expr $x+1]; exp_continue; }
 
3066
        -re ".* 1141 1e14 7D9013D0" { set x [expr $x+1]; exp_continue; }
 
3067
        -re ".* 1142 1e18 01576918" { set x [expr $x+1]; exp_continue; }
 
3068
        -re ".* 1142      13D0" { set x [expr $x+1]; exp_continue; }
 
3069
        -re ".* 1143 1e1e 01546D18" { set x [expr $x+1]; exp_continue; }
 
3070
        -re ".* 1143      13D0" { set x [expr $x+1]; exp_continue; }
 
3071
        -re ".* 1144 1e24 01576D18" { set x [expr $x+1]; exp_continue; }
 
3072
        -re ".* 1144      13D0" { set x [expr $x+1]; exp_continue; }
 
3073
        -re ".* 1145 1e2a 01556D18" { set x [expr $x+1]; exp_continue; }
 
3074
        -re ".* 1145      13D0" { set x [expr $x+1]; exp_continue; }
 
3075
        -re ".* 1146 1e30 01566D18" { set x [expr $x+1]; exp_continue; }
 
3076
        -re ".* 1146      13D0" { set x [expr $x+1]; exp_continue; }
 
3077
        -re ".* 1147 1e36 01546F18" { set x [expr $x+1]; exp_continue; }
 
3078
        -re ".* 1147      123413D0" { set x [expr $x+1]; exp_continue; }
 
3079
        -re ".* 1148 1e3e 78146B28" { set x [expr $x+1]; exp_continue; }
 
3080
        -re ".* 1148      12345678" { set x [expr $x+1]; exp_continue; }
 
3081
        -re ".* 1148      13D0" { set x [expr $x+1]; exp_continue; }
 
3082
        -re ".* 1149 1e48 01556F28" { set x [expr $x+1]; exp_continue; }
 
3083
        -re ".* 1149      123413D0" { set x [expr $x+1]; exp_continue; }
 
3084
        -re ".* 1150 1e50 01566F28" { set x [expr $x+1]; exp_continue; }
 
3085
        -re ".* 1150      123413D0" { set x [expr $x+1]; exp_continue; }
 
3086
        -re ".* 1151 1e58 01576F28" { set x [expr $x+1]; exp_continue; }
 
3087
        -re ".* 1151      123413D0" { set x [expr $x+1]; exp_continue; }
 
3088
        -re ".* 1152 1e60 78256B28" { set x [expr $x+1]; exp_continue; }
 
3089
        -re ".* 1152      12345678" { set x [expr $x+1]; exp_continue; }
 
3090
        -re ".* 1152      13D0" { set x [expr $x+1]; exp_continue; }
 
3091
        -re ".* 1153 1e6a 78266B28" { set x [expr $x+1]; exp_continue; }
 
3092
        -re ".* 1153      12345678" { set x [expr $x+1]; exp_continue; }
 
3093
        -re ".* 1153      13D0" { set x [expr $x+1]; exp_continue; }
 
3094
        -re ".* 1154 1e74 78276B28" { set x [expr $x+1]; exp_continue; }
 
3095
        -re ".* 1154      12345678" { set x [expr $x+1]; exp_continue; }
 
3096
        -re ".* 1154      13D0" { set x [expr $x+1]; exp_continue; }
 
3097
        -re ".* 1155 1e7e 6B181234" { set x [expr $x+1]; exp_continue; }
 
3098
        -re ".* 1155      13D0" { set x [expr $x+1]; exp_continue; }
 
3099
        -re ".* 1156 1e84 6B381234" { set x [expr $x+1]; exp_continue; }
 
3100
        -re ".* 1156      567813D0" { set x [expr $x+1]; exp_continue; }
 
3101
        -re ".* 1157             " {
 
3102
            if [expr $x == 36] then {
 
3103
                pass "$testname: rotr.w #2, ..."
 
3104
            } else {
 
3105
                fail "$testname: rotr.w #2, ... ($x)"
 
3106
            }
 
3107
        }
 
3108
        default { fail "$testname: rotr.w #2, ... ($x)" }
 
3109
    }
 
3110
 
 
3111
    set x 0
 
3112
    expect {
 
3113
        -re ".* 1158 1e8c 13F1" { set x [expr $x+1]; exp_continue; }
 
3114
        -re ".* 1159 1e8e 01046918" { set x [expr $x+1]; exp_continue; }
 
3115
        -re ".* 1159      13F0" { set x [expr $x+1]; exp_continue; }
 
3116
        -re ".* 1160 1e94 01076918" { set x [expr $x+1]; exp_continue; }
 
3117
        -re ".* 1160      13F0" { set x [expr $x+1]; exp_continue; }
 
3118
        -re ".* 1161 1e9a 01046D18" { set x [expr $x+1]; exp_continue; }
 
3119
        -re ".* 1161      13F0" { set x [expr $x+1]; exp_continue; }
 
3120
        -re ".* 1162 1ea0 01076D18" { set x [expr $x+1]; exp_continue; }
 
3121
        -re ".* 1162      13F0" { set x [expr $x+1]; exp_continue; }
 
3122
        -re ".* 1163 1ea6 01056D18" { set x [expr $x+1]; exp_continue; }
 
3123
        -re ".* 1163      13F0" { set x [expr $x+1]; exp_continue; }
 
3124
        -re ".* 1164 1eac 01066D18" { set x [expr $x+1]; exp_continue; }
 
3125
        -re ".* 1164      13F0" { set x [expr $x+1]; exp_continue; }
 
3126
        -re ".* 1165 1eb2 01046F18" { set x [expr $x+1]; exp_continue; }
 
3127
        -re ".* 1165      123413F0" { set x [expr $x+1]; exp_continue; }
 
3128
        -re ".* 1166 1eba 78946B28" { set x [expr $x+1]; exp_continue; }
 
3129
        -re ".* 1166      12345678" { set x [expr $x+1]; exp_continue; }
 
3130
        -re ".* 1166      13F0" { set x [expr $x+1]; exp_continue; }
 
3131
        -re ".* 1167 1ec4 01056F28" { set x [expr $x+1]; exp_continue; }
 
3132
        -re ".* 1167      123413F0" { set x [expr $x+1]; exp_continue; }
 
3133
        -re ".* 1168 1ecc 01066F28" { set x [expr $x+1]; exp_continue; }
 
3134
        -re ".* 1168      123413F0" { set x [expr $x+1]; exp_continue; }
 
3135
        -re ".* 1169 1ed4 01076F28" { set x [expr $x+1]; exp_continue; }
 
3136
        -re ".* 1169      123413F0" { set x [expr $x+1]; exp_continue; }
 
3137
        -re ".* 1170 1edc 78A56B28" { set x [expr $x+1]; exp_continue; }
 
3138
        -re ".* 1170      12345678" { set x [expr $x+1]; exp_continue; }
 
3139
        -re ".* 1170      13F0" { set x [expr $x+1]; exp_continue; }
 
3140
        -re ".* 1171 1ee6 78A66B28" { set x [expr $x+1]; exp_continue; }
 
3141
        -re ".* 1171      12345678" { set x [expr $x+1]; exp_continue; }
 
3142
        -re ".* 1171      13F0" { set x [expr $x+1]; exp_continue; }
 
3143
        -re ".* 1172 1ef0 78A76B28" { set x [expr $x+1]; exp_continue; }
 
3144
        -re ".* 1172      12345678" { set x [expr $x+1]; exp_continue; }
 
3145
        -re ".* 1172      13F0" { set x [expr $x+1]; exp_continue; }
 
3146
        -re ".* 1173 1efa 01046B08" { set x [expr $x+1]; exp_continue; }
 
3147
        -re ".* 1173      123413F0" { set x [expr $x+1]; exp_continue; }
 
3148
        -re ".* 1174 1f02 01046B28" { set x [expr $x+1]; exp_continue; }
 
3149
        -re ".* 1174      12345678" { set x [expr $x+1]; exp_continue; }
 
3150
        -re ".* 1174      13F0" { set x [expr $x+1]; exp_continue; }
 
3151
        -re ".* 1175             " {
 
3152
            if [expr $x == 38] then {
 
3153
                pass "$testname: rotr.l #2, ..."
 
3154
            } else {
 
3155
                fail "$testname: rotr.l #2, ... ($x)"
 
3156
            }
 
3157
        }
 
3158
        default { fail "$testname: rotr.l #2, ... ($x)" }
 
3159
    }
 
3160
 
 
3161
    # This was intended to do any cleanup necessary.
 
3162
    # It kinda looks like it isn't needed, but just
 
3163
    # in case, please keep it in for now.
 
3164
 
 
3165
    gas_finish
 
3166
 
 
3167
}
 
3168
 
 
3169
if [istarget h8300*-*-elf] then {
 
3170
    # Test advanced h8300sx instructions.
 
3171
    do_t11_logs_test
 
3172
}
 
3173