1
2 #include <pthread.h>
3 #include <assert.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6
7 #include "helgrind/helgrind.h"
8
9 typedef
10 struct {
11 void* (*child)(void*);
12 char* arr;
13 int firstoff;
14 int lastoff;
15 int skipoff;
16 }
17 Info;
18
19 pthread_mutex_t mx;
20
child8(void * infoV)21 void* child8 ( void* infoV )
22 {
23 int r, i, firstoff, lastoff, skipoff;
24 char* arr;
25 Info* info = (Info*)infoV;
26 firstoff = info->firstoff;
27 lastoff = info->lastoff;
28 skipoff = info->skipoff;
29 arr = info->arr;
30 assert( sizeof(char) == 1 );
31 assert( info->child == &child8 );
32 { char* ptr = (char*)&arr[skipoff];
33 *ptr = 0; }
34 for (i = firstoff; i <= lastoff; i += 1) {
35 char* ptr = (char*)&arr[i];
36 if (i != skipoff) {
37 r= pthread_mutex_lock( &mx ); assert(!r);
38 *ptr = 0;
39 r= pthread_mutex_unlock( &mx ); assert(!r);
40 }
41 }
42 return NULL;
43 }
44
child16(void * infoV)45 void* child16 ( void* infoV )
46 {
47 int r, i, firstoff, lastoff, skipoff;
48 char* arr;
49 Info* info = (Info*)infoV;
50 firstoff = info->firstoff;
51 lastoff = info->lastoff;
52 skipoff = info->skipoff;
53 arr = info->arr;
54 assert( sizeof(short) == 2 );
55 assert( info->child == &child16 );
56 { short* ptr = (short*)&arr[skipoff];
57 *ptr = 0; }
58 for (i = firstoff; i <= lastoff; i += 2) {
59 short* ptr = (short*)&arr[i];
60 if (i != skipoff) {
61 r= pthread_mutex_lock( &mx ); assert(!r);
62 *ptr = 0;
63 r= pthread_mutex_unlock( &mx ); assert(!r);
64 }
65 }
66 return NULL;
67 }
68
child32(void * infoV)69 void* child32 ( void* infoV )
70 {
71 int r, i, firstoff, lastoff, skipoff;
72 char* arr;
73 Info* info = (Info*)infoV;
74 firstoff = info->firstoff;
75 lastoff = info->lastoff;
76 skipoff = info->skipoff;
77 arr = info->arr;
78 assert( sizeof(int) == 4 );
79 assert( info->child == &child32 );
80 { int* ptr = (int*)&arr[skipoff];
81 *ptr = 0; }
82 for (i = firstoff; i <= lastoff; i += 4) {
83 int* ptr = (int*)&arr[i];
84 if (i != skipoff) {
85 r= pthread_mutex_lock( &mx ); assert(!r);
86 *ptr = 0;
87 r= pthread_mutex_unlock( &mx ); assert(!r);
88 }
89 }
90 return NULL;
91 }
92
child64(void * infoV)93 void* child64 ( void* infoV )
94 {
95 int r, i, firstoff, lastoff, skipoff;
96 char* arr;
97 Info* info = (Info*)infoV;
98 firstoff = info->firstoff;
99 lastoff = info->lastoff;
100 skipoff = info->skipoff;
101 arr = info->arr;
102 assert( sizeof(double) == 8 );
103 assert( info->child == &child64 );
104 { double* ptr = (double*)&arr[skipoff];
105 *ptr = 0.0; }
106 for (i = firstoff; i <= lastoff; i += 8) {
107 double* ptr = (double*)&arr[i];
108 if (i != skipoff) {
109 r= pthread_mutex_lock( &mx ); assert(!r);
110 *ptr = 0.0;
111 r= pthread_mutex_unlock( &mx ); assert(!r);
112 }
113 }
114 return NULL;
115 }
116
117
118 void* steer ( void* infoV );
119
120 #define MAXXX 100 /* re 100: should cover at least 2 cycles
121 of length 1 << N_LINE_BITS */
122 /* This is all a bit subtle. First, after every inner loop over the
123 data, we have to VALGRIND_TC_CLEAN_MEMORY it to get it back to a
124 decent starting state. Because info.arr is 8-aligned (is asserted
125 for), the address range painter will paint at top level granularity
126 (8-byte), which means we are guaranteed to see any errors from the
127 next iteration at the maximum granularity that their alignment
128 allows.
129
130 Also, the pthread_joins cause the shadow mem cache to be flushed
131 each iteration. Given that all trees are pulled up to 64-bit by
132 the abovementioned VALGRIND_TC_CLEAN_MEMORY, I think this
133 irrelevant.
134 */
135
main(void)136 int main ( void )
137 {
138 pthread_t t1, t2;
139 Info info;
140 int off;
141
142 pthread_mutex_init( &mx, NULL );
143
144 info.arr = malloc(MAXXX);
145 assert(info.arr);
146
147 /* ensure array is 8-aligned. this is important, as per comment
148 above. */
149 assert(0 == (7 & (unsigned long)info.arr));
150
151 #if 1
152 /* Test 8 bit granularity */
153
154 fprintf(stderr, "\n");
155 fprintf(stderr,
156 "===========================================================\n");
157 fprintf(stderr,
158 "=== 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 ===\n");
159 fprintf(stderr,
160 "===========================================================\n");
161 fprintf(stderr, "\n");
162 for (off = 0; off < MAXXX-1; off++) {
163
164 info.firstoff = off & 0;
165 info.lastoff = MAXXX - 1;
166 info.skipoff = off;
167 info.child = child8;
168
169 fprintf(stderr, "---------- char gran, %d .. %d, skip %d ----------\n",
170 info.firstoff, info.lastoff, info.skipoff );
171
172 pthread_create( &t1, NULL, steer, (void*)&info );
173 pthread_create( &t2, NULL, steer, (void*)&info );
174
175 pthread_join( t1, NULL );
176 pthread_join( t2, NULL );
177
178 VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
179
180 }
181 #endif
182 #if 1
183 /* Test 16 bit granularity */
184
185 fprintf(stderr, "\n");
186 fprintf(stderr,
187 "==========================================================\n");
188 fprintf(stderr,
189 "=== 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 ===\n");
190 fprintf(stderr,
191 "==========================================================\n");
192 fprintf(stderr, "\n");
193 for (off = 0; off < MAXXX-2; off++) {
194
195 info.firstoff = off & 1;
196 info.lastoff = MAXXX - 2;
197 info.skipoff = off;
198 info.child = child16;
199
200 fprintf(stderr, "---------- short gran, %d .. %d, skip %d ----------\n",
201 info.firstoff, info.lastoff, info.skipoff );
202
203 pthread_create( &t1, NULL, steer, (void*)&info );
204 pthread_create( &t2, NULL, steer, (void*)&info );
205
206 pthread_join( t1, NULL );
207 pthread_join( t2, NULL );
208
209 VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
210
211 }
212 #endif
213 #if 1
214 /* Test 32 bit granularity */
215
216 fprintf(stderr, "\n");
217 fprintf(stderr,
218 "==========================================================\n");
219 fprintf(stderr,
220 "=== 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 ===\n");
221 fprintf(stderr,
222 "==========================================================\n");
223 fprintf(stderr, "\n");
224 for (off = 0; off < MAXXX-4; off++) {
225
226 info.firstoff = off & 3;
227 info.lastoff = MAXXX - 4;
228 info.skipoff = off;
229 info.child = child32;
230
231 fprintf(stderr, "---------- int gran, %d .. %d, skip %d ----------\n",
232 info.firstoff, info.lastoff, info.skipoff );
233
234 pthread_create( &t1, NULL, steer, (void*)&info );
235 pthread_create( &t2, NULL, steer, (void*)&info );
236
237 pthread_join( t1, NULL );
238 pthread_join( t2, NULL );
239
240 VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
241
242 }
243 #endif
244 #if 1
245 /* Test 64 bit granularity */
246
247 fprintf(stderr, "\n");
248 fprintf(stderr,
249 "==========================================================\n");
250 fprintf(stderr,
251 "=== 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 ===\n");
252 fprintf(stderr,
253 "==========================================================\n");
254 fprintf(stderr, "\n");
255 for (off = 0; off < MAXXX-8; off++) {
256
257 info.firstoff = off & 7;
258 info.lastoff = MAXXX - 8;
259 info.skipoff = off;
260 info.child = child64;
261
262 fprintf(stderr, "---------- double gran, %d .. %d, skip %d ----------\n",
263 info.firstoff, info.lastoff, info.skipoff );
264
265 pthread_create( &t1, NULL, steer, (void*)&info );
266 pthread_create( &t2, NULL, steer, (void*)&info );
267
268 pthread_join( t1, NULL );
269 pthread_join( t2, NULL );
270
271 VALGRIND_HG_CLEAN_MEMORY(&info.arr[0], MAXXX);
272
273 }
274 #endif
275 free(info.arr);
276
277 return 0;
278 }
279
steer(void * infoV)280 void* steer ( void* infoV )
281 {
282 Info* info = (Info*)infoV;
283 int wot = info->skipoff;
284 void*(*fn)(void*) = info->child;
285 if (wot >= 500) goto halfway;
286
287 __asm__ __volatile__("");
288 if (wot == 0) return fn(info);
289 __asm__ __volatile__("");
290 if (wot == 1) return fn(info);
291 __asm__ __volatile__("");
292 if (wot == 2) return fn(info);
293 __asm__ __volatile__("");
294 if (wot == 3) return fn(info);
295 __asm__ __volatile__("");
296 if (wot == 4) return fn(info);
297 __asm__ __volatile__("");
298 if (wot == 5) return fn(info);
299 __asm__ __volatile__("");
300 if (wot == 6) return fn(info);
301 __asm__ __volatile__("");
302 if (wot == 7) return fn(info);
303 __asm__ __volatile__("");
304 if (wot == 8) return fn(info);
305 __asm__ __volatile__("");
306 if (wot == 9) return fn(info);
307 __asm__ __volatile__("");
308 if (wot == 10) return fn(info);
309 __asm__ __volatile__("");
310 if (wot == 11) return fn(info);
311 __asm__ __volatile__("");
312 if (wot == 12) return fn(info);
313 __asm__ __volatile__("");
314 if (wot == 13) return fn(info);
315 __asm__ __volatile__("");
316 if (wot == 14) return fn(info);
317 __asm__ __volatile__("");
318 if (wot == 15) return fn(info);
319 __asm__ __volatile__("");
320 if (wot == 16) return fn(info);
321 __asm__ __volatile__("");
322 if (wot == 17) return fn(info);
323 __asm__ __volatile__("");
324 if (wot == 18) return fn(info);
325 __asm__ __volatile__("");
326 if (wot == 19) return fn(info);
327 __asm__ __volatile__("");
328 if (wot == 20) return fn(info);
329 __asm__ __volatile__("");
330 if (wot == 21) return fn(info);
331 __asm__ __volatile__("");
332 if (wot == 22) return fn(info);
333 __asm__ __volatile__("");
334 if (wot == 23) return fn(info);
335 __asm__ __volatile__("");
336 if (wot == 24) return fn(info);
337 __asm__ __volatile__("");
338 if (wot == 25) return fn(info);
339 __asm__ __volatile__("");
340 if (wot == 26) return fn(info);
341 __asm__ __volatile__("");
342 if (wot == 27) return fn(info);
343 __asm__ __volatile__("");
344 if (wot == 28) return fn(info);
345 __asm__ __volatile__("");
346 if (wot == 29) return fn(info);
347 __asm__ __volatile__("");
348 if (wot == 30) return fn(info);
349 __asm__ __volatile__("");
350 if (wot == 31) return fn(info);
351 __asm__ __volatile__("");
352 if (wot == 32) return fn(info);
353 __asm__ __volatile__("");
354 if (wot == 33) return fn(info);
355 __asm__ __volatile__("");
356 if (wot == 34) return fn(info);
357 __asm__ __volatile__("");
358 if (wot == 35) return fn(info);
359 __asm__ __volatile__("");
360 if (wot == 36) return fn(info);
361 __asm__ __volatile__("");
362 if (wot == 37) return fn(info);
363 __asm__ __volatile__("");
364 if (wot == 38) return fn(info);
365 __asm__ __volatile__("");
366 if (wot == 39) return fn(info);
367 __asm__ __volatile__("");
368 if (wot == 40) return fn(info);
369 __asm__ __volatile__("");
370 if (wot == 41) return fn(info);
371 __asm__ __volatile__("");
372 if (wot == 42) return fn(info);
373 __asm__ __volatile__("");
374 if (wot == 43) return fn(info);
375 __asm__ __volatile__("");
376 if (wot == 44) return fn(info);
377 __asm__ __volatile__("");
378 if (wot == 45) return fn(info);
379 __asm__ __volatile__("");
380 if (wot == 46) return fn(info);
381 __asm__ __volatile__("");
382 if (wot == 47) return fn(info);
383 __asm__ __volatile__("");
384 if (wot == 48) return fn(info);
385 __asm__ __volatile__("");
386 if (wot == 49) return fn(info);
387 __asm__ __volatile__("");
388 if (wot == 50) return fn(info);
389 __asm__ __volatile__("");
390 if (wot == 51) return fn(info);
391 __asm__ __volatile__("");
392 if (wot == 52) return fn(info);
393 __asm__ __volatile__("");
394 if (wot == 53) return fn(info);
395 __asm__ __volatile__("");
396 if (wot == 54) return fn(info);
397 __asm__ __volatile__("");
398 if (wot == 55) return fn(info);
399 __asm__ __volatile__("");
400 if (wot == 56) return fn(info);
401 __asm__ __volatile__("");
402 if (wot == 57) return fn(info);
403 __asm__ __volatile__("");
404 if (wot == 58) return fn(info);
405 __asm__ __volatile__("");
406 if (wot == 59) return fn(info);
407 __asm__ __volatile__("");
408 if (wot == 60) return fn(info);
409 __asm__ __volatile__("");
410 if (wot == 61) return fn(info);
411 __asm__ __volatile__("");
412 if (wot == 62) return fn(info);
413 __asm__ __volatile__("");
414 if (wot == 63) return fn(info);
415 __asm__ __volatile__("");
416 if (wot == 64) return fn(info);
417 __asm__ __volatile__("");
418 if (wot == 65) return fn(info);
419 __asm__ __volatile__("");
420 if (wot == 66) return fn(info);
421 __asm__ __volatile__("");
422 if (wot == 67) return fn(info);
423 __asm__ __volatile__("");
424 if (wot == 68) return fn(info);
425 __asm__ __volatile__("");
426 if (wot == 69) return fn(info);
427 __asm__ __volatile__("");
428 if (wot == 70) return fn(info);
429 __asm__ __volatile__("");
430 if (wot == 71) return fn(info);
431 __asm__ __volatile__("");
432 if (wot == 72) return fn(info);
433 __asm__ __volatile__("");
434 if (wot == 73) return fn(info);
435 __asm__ __volatile__("");
436 if (wot == 74) return fn(info);
437 __asm__ __volatile__("");
438 if (wot == 75) return fn(info);
439 __asm__ __volatile__("");
440 if (wot == 76) return fn(info);
441 __asm__ __volatile__("");
442 if (wot == 77) return fn(info);
443 __asm__ __volatile__("");
444 if (wot == 78) return fn(info);
445 __asm__ __volatile__("");
446 if (wot == 79) return fn(info);
447 __asm__ __volatile__("");
448 if (wot == 80) return fn(info);
449 __asm__ __volatile__("");
450 if (wot == 81) return fn(info);
451 __asm__ __volatile__("");
452 if (wot == 82) return fn(info);
453 __asm__ __volatile__("");
454 if (wot == 83) return fn(info);
455 __asm__ __volatile__("");
456 if (wot == 84) return fn(info);
457 __asm__ __volatile__("");
458 if (wot == 85) return fn(info);
459 __asm__ __volatile__("");
460 if (wot == 86) return fn(info);
461 __asm__ __volatile__("");
462 if (wot == 87) return fn(info);
463 __asm__ __volatile__("");
464 if (wot == 88) return fn(info);
465 __asm__ __volatile__("");
466 if (wot == 89) return fn(info);
467 __asm__ __volatile__("");
468 if (wot == 90) return fn(info);
469 __asm__ __volatile__("");
470 if (wot == 91) return fn(info);
471 __asm__ __volatile__("");
472 if (wot == 92) return fn(info);
473 __asm__ __volatile__("");
474 if (wot == 93) return fn(info);
475 __asm__ __volatile__("");
476 if (wot == 94) return fn(info);
477 __asm__ __volatile__("");
478 if (wot == 95) return fn(info);
479 __asm__ __volatile__("");
480 if (wot == 96) return fn(info);
481 __asm__ __volatile__("");
482 if (wot == 97) return fn(info);
483 __asm__ __volatile__("");
484 if (wot == 98) return fn(info);
485 __asm__ __volatile__("");
486 if (wot == 99) return fn(info);
487 __asm__ __volatile__("");
488 if (wot == 100) return fn(info);
489 __asm__ __volatile__("");
490 if (wot == 101) return fn(info);
491 __asm__ __volatile__("");
492 if (wot == 102) return fn(info);
493 __asm__ __volatile__("");
494 if (wot == 103) return fn(info);
495 __asm__ __volatile__("");
496 if (wot == 104) return fn(info);
497 __asm__ __volatile__("");
498 if (wot == 105) return fn(info);
499 __asm__ __volatile__("");
500 if (wot == 106) return fn(info);
501 __asm__ __volatile__("");
502 if (wot == 107) return fn(info);
503 __asm__ __volatile__("");
504 if (wot == 108) return fn(info);
505 __asm__ __volatile__("");
506 if (wot == 109) return fn(info);
507 __asm__ __volatile__("");
508 if (wot == 110) return fn(info);
509 __asm__ __volatile__("");
510 if (wot == 111) return fn(info);
511 __asm__ __volatile__("");
512 if (wot == 112) return fn(info);
513 __asm__ __volatile__("");
514 if (wot == 113) return fn(info);
515 __asm__ __volatile__("");
516 if (wot == 114) return fn(info);
517 __asm__ __volatile__("");
518 if (wot == 115) return fn(info);
519 __asm__ __volatile__("");
520 if (wot == 116) return fn(info);
521 __asm__ __volatile__("");
522 if (wot == 117) return fn(info);
523 __asm__ __volatile__("");
524 if (wot == 118) return fn(info);
525 __asm__ __volatile__("");
526 if (wot == 119) return fn(info);
527 __asm__ __volatile__("");
528 if (wot == 120) return fn(info);
529 __asm__ __volatile__("");
530 if (wot == 121) return fn(info);
531 __asm__ __volatile__("");
532 if (wot == 122) return fn(info);
533 __asm__ __volatile__("");
534 if (wot == 123) return fn(info);
535 __asm__ __volatile__("");
536 if (wot == 124) return fn(info);
537 __asm__ __volatile__("");
538 if (wot == 125) return fn(info);
539 __asm__ __volatile__("");
540 if (wot == 126) return fn(info);
541 __asm__ __volatile__("");
542 if (wot == 127) return fn(info);
543 __asm__ __volatile__("");
544 if (wot == 128) return fn(info);
545 __asm__ __volatile__("");
546 if (wot == 129) return fn(info);
547 __asm__ __volatile__("");
548 if (wot == 130) return fn(info);
549 __asm__ __volatile__("");
550 if (wot == 131) return fn(info);
551 __asm__ __volatile__("");
552 if (wot == 132) return fn(info);
553 __asm__ __volatile__("");
554 if (wot == 133) return fn(info);
555 __asm__ __volatile__("");
556 if (wot == 134) return fn(info);
557 __asm__ __volatile__("");
558 if (wot == 135) return fn(info);
559 __asm__ __volatile__("");
560 if (wot == 136) return fn(info);
561 __asm__ __volatile__("");
562 if (wot == 137) return fn(info);
563 __asm__ __volatile__("");
564 if (wot == 138) return fn(info);
565 __asm__ __volatile__("");
566 if (wot == 139) return fn(info);
567 __asm__ __volatile__("");
568 if (wot == 140) return fn(info);
569 __asm__ __volatile__("");
570 if (wot == 141) return fn(info);
571 __asm__ __volatile__("");
572 if (wot == 142) return fn(info);
573 __asm__ __volatile__("");
574 if (wot == 143) return fn(info);
575 __asm__ __volatile__("");
576 if (wot == 144) return fn(info);
577 __asm__ __volatile__("");
578 if (wot == 145) return fn(info);
579 __asm__ __volatile__("");
580 if (wot == 146) return fn(info);
581 __asm__ __volatile__("");
582 if (wot == 147) return fn(info);
583 __asm__ __volatile__("");
584 if (wot == 148) return fn(info);
585 __asm__ __volatile__("");
586 if (wot == 149) return fn(info);
587 __asm__ __volatile__("");
588 if (wot == 150) return fn(info);
589 __asm__ __volatile__("");
590 if (wot == 151) return fn(info);
591 __asm__ __volatile__("");
592 if (wot == 152) return fn(info);
593 __asm__ __volatile__("");
594 if (wot == 153) return fn(info);
595 __asm__ __volatile__("");
596 if (wot == 154) return fn(info);
597 __asm__ __volatile__("");
598 if (wot == 155) return fn(info);
599 __asm__ __volatile__("");
600 if (wot == 156) return fn(info);
601 __asm__ __volatile__("");
602 if (wot == 157) return fn(info);
603 __asm__ __volatile__("");
604 if (wot == 158) return fn(info);
605 __asm__ __volatile__("");
606 if (wot == 159) return fn(info);
607 __asm__ __volatile__("");
608 if (wot == 160) return fn(info);
609 __asm__ __volatile__("");
610 if (wot == 161) return fn(info);
611 __asm__ __volatile__("");
612 if (wot == 162) return fn(info);
613 __asm__ __volatile__("");
614 if (wot == 163) return fn(info);
615 __asm__ __volatile__("");
616 if (wot == 164) return fn(info);
617 __asm__ __volatile__("");
618 if (wot == 165) return fn(info);
619 __asm__ __volatile__("");
620 if (wot == 166) return fn(info);
621 __asm__ __volatile__("");
622 if (wot == 167) return fn(info);
623 __asm__ __volatile__("");
624 if (wot == 168) return fn(info);
625 __asm__ __volatile__("");
626 if (wot == 169) return fn(info);
627 __asm__ __volatile__("");
628 if (wot == 170) return fn(info);
629 __asm__ __volatile__("");
630 if (wot == 171) return fn(info);
631 __asm__ __volatile__("");
632 if (wot == 172) return fn(info);
633 __asm__ __volatile__("");
634 if (wot == 173) return fn(info);
635 __asm__ __volatile__("");
636 if (wot == 174) return fn(info);
637 __asm__ __volatile__("");
638 if (wot == 175) return fn(info);
639 __asm__ __volatile__("");
640 if (wot == 176) return fn(info);
641 __asm__ __volatile__("");
642 if (wot == 177) return fn(info);
643 __asm__ __volatile__("");
644 if (wot == 178) return fn(info);
645 __asm__ __volatile__("");
646 if (wot == 179) return fn(info);
647 __asm__ __volatile__("");
648 if (wot == 180) return fn(info);
649 __asm__ __volatile__("");
650 if (wot == 181) return fn(info);
651 __asm__ __volatile__("");
652 if (wot == 182) return fn(info);
653 __asm__ __volatile__("");
654 if (wot == 183) return fn(info);
655 __asm__ __volatile__("");
656 if (wot == 184) return fn(info);
657 __asm__ __volatile__("");
658 if (wot == 185) return fn(info);
659 __asm__ __volatile__("");
660 if (wot == 186) return fn(info);
661 __asm__ __volatile__("");
662 if (wot == 187) return fn(info);
663 __asm__ __volatile__("");
664 if (wot == 188) return fn(info);
665 __asm__ __volatile__("");
666 if (wot == 189) return fn(info);
667 __asm__ __volatile__("");
668 if (wot == 190) return fn(info);
669 __asm__ __volatile__("");
670 if (wot == 191) return fn(info);
671 __asm__ __volatile__("");
672 if (wot == 192) return fn(info);
673 __asm__ __volatile__("");
674 if (wot == 193) return fn(info);
675 __asm__ __volatile__("");
676 if (wot == 194) return fn(info);
677 __asm__ __volatile__("");
678 if (wot == 195) return fn(info);
679 __asm__ __volatile__("");
680 if (wot == 196) return fn(info);
681 __asm__ __volatile__("");
682 if (wot == 197) return fn(info);
683 __asm__ __volatile__("");
684 if (wot == 198) return fn(info);
685 __asm__ __volatile__("");
686 if (wot == 199) return fn(info);
687 __asm__ __volatile__("");
688 if (wot == 200) return fn(info);
689 __asm__ __volatile__("");
690 if (wot == 201) return fn(info);
691 __asm__ __volatile__("");
692 if (wot == 202) return fn(info);
693 __asm__ __volatile__("");
694 if (wot == 203) return fn(info);
695 __asm__ __volatile__("");
696 if (wot == 204) return fn(info);
697 __asm__ __volatile__("");
698 if (wot == 205) return fn(info);
699 __asm__ __volatile__("");
700 if (wot == 206) return fn(info);
701 __asm__ __volatile__("");
702 if (wot == 207) return fn(info);
703 __asm__ __volatile__("");
704 if (wot == 208) return fn(info);
705 __asm__ __volatile__("");
706 if (wot == 209) return fn(info);
707 __asm__ __volatile__("");
708 if (wot == 210) return fn(info);
709 __asm__ __volatile__("");
710 if (wot == 211) return fn(info);
711 __asm__ __volatile__("");
712 if (wot == 212) return fn(info);
713 __asm__ __volatile__("");
714 if (wot == 213) return fn(info);
715 __asm__ __volatile__("");
716 if (wot == 214) return fn(info);
717 __asm__ __volatile__("");
718 if (wot == 215) return fn(info);
719 __asm__ __volatile__("");
720 if (wot == 216) return fn(info);
721 __asm__ __volatile__("");
722 if (wot == 217) return fn(info);
723 __asm__ __volatile__("");
724 if (wot == 218) return fn(info);
725 __asm__ __volatile__("");
726 if (wot == 219) return fn(info);
727 __asm__ __volatile__("");
728 if (wot == 220) return fn(info);
729 __asm__ __volatile__("");
730 if (wot == 221) return fn(info);
731 __asm__ __volatile__("");
732 if (wot == 222) return fn(info);
733 __asm__ __volatile__("");
734 if (wot == 223) return fn(info);
735 __asm__ __volatile__("");
736 if (wot == 224) return fn(info);
737 __asm__ __volatile__("");
738 if (wot == 225) return fn(info);
739 __asm__ __volatile__("");
740 if (wot == 226) return fn(info);
741 __asm__ __volatile__("");
742 if (wot == 227) return fn(info);
743 __asm__ __volatile__("");
744 if (wot == 228) return fn(info);
745 __asm__ __volatile__("");
746 if (wot == 229) return fn(info);
747 __asm__ __volatile__("");
748 if (wot == 230) return fn(info);
749 __asm__ __volatile__("");
750 if (wot == 231) return fn(info);
751 __asm__ __volatile__("");
752 if (wot == 232) return fn(info);
753 __asm__ __volatile__("");
754 if (wot == 233) return fn(info);
755 __asm__ __volatile__("");
756 if (wot == 234) return fn(info);
757 __asm__ __volatile__("");
758 if (wot == 235) return fn(info);
759 __asm__ __volatile__("");
760 if (wot == 236) return fn(info);
761 __asm__ __volatile__("");
762 if (wot == 237) return fn(info);
763 __asm__ __volatile__("");
764 if (wot == 238) return fn(info);
765 __asm__ __volatile__("");
766 if (wot == 239) return fn(info);
767 __asm__ __volatile__("");
768 if (wot == 240) return fn(info);
769 __asm__ __volatile__("");
770 if (wot == 241) return fn(info);
771 __asm__ __volatile__("");
772 if (wot == 242) return fn(info);
773 __asm__ __volatile__("");
774 if (wot == 243) return fn(info);
775 __asm__ __volatile__("");
776 if (wot == 244) return fn(info);
777 __asm__ __volatile__("");
778 if (wot == 245) return fn(info);
779 __asm__ __volatile__("");
780 if (wot == 246) return fn(info);
781 __asm__ __volatile__("");
782 if (wot == 247) return fn(info);
783 __asm__ __volatile__("");
784 if (wot == 248) return fn(info);
785 __asm__ __volatile__("");
786 if (wot == 249) return fn(info);
787 __asm__ __volatile__("");
788 if (wot == 250) return fn(info);
789 __asm__ __volatile__("");
790 if (wot == 251) return fn(info);
791 __asm__ __volatile__("");
792 if (wot == 252) return fn(info);
793 __asm__ __volatile__("");
794 if (wot == 253) return fn(info);
795 __asm__ __volatile__("");
796 if (wot == 254) return fn(info);
797 __asm__ __volatile__("");
798 if (wot == 255) return fn(info);
799 __asm__ __volatile__("");
800 if (wot == 256) return fn(info);
801 __asm__ __volatile__("");
802 if (wot == 257) return fn(info);
803 __asm__ __volatile__("");
804 if (wot == 258) return fn(info);
805 __asm__ __volatile__("");
806 if (wot == 259) return fn(info);
807 __asm__ __volatile__("");
808 if (wot == 260) return fn(info);
809 __asm__ __volatile__("");
810 if (wot == 261) return fn(info);
811 __asm__ __volatile__("");
812 if (wot == 262) return fn(info);
813 __asm__ __volatile__("");
814 if (wot == 263) return fn(info);
815 __asm__ __volatile__("");
816 if (wot == 264) return fn(info);
817 __asm__ __volatile__("");
818 if (wot == 265) return fn(info);
819 __asm__ __volatile__("");
820 if (wot == 266) return fn(info);
821 __asm__ __volatile__("");
822 if (wot == 267) return fn(info);
823 __asm__ __volatile__("");
824 if (wot == 268) return fn(info);
825 __asm__ __volatile__("");
826 if (wot == 269) return fn(info);
827 __asm__ __volatile__("");
828 if (wot == 270) return fn(info);
829 __asm__ __volatile__("");
830 if (wot == 271) return fn(info);
831 __asm__ __volatile__("");
832 if (wot == 272) return fn(info);
833 __asm__ __volatile__("");
834 if (wot == 273) return fn(info);
835 __asm__ __volatile__("");
836 if (wot == 274) return fn(info);
837 __asm__ __volatile__("");
838 if (wot == 275) return fn(info);
839 __asm__ __volatile__("");
840 if (wot == 276) return fn(info);
841 __asm__ __volatile__("");
842 if (wot == 277) return fn(info);
843 __asm__ __volatile__("");
844 if (wot == 278) return fn(info);
845 __asm__ __volatile__("");
846 if (wot == 279) return fn(info);
847 __asm__ __volatile__("");
848 if (wot == 280) return fn(info);
849 __asm__ __volatile__("");
850 if (wot == 281) return fn(info);
851 __asm__ __volatile__("");
852 if (wot == 282) return fn(info);
853 __asm__ __volatile__("");
854 if (wot == 283) return fn(info);
855 __asm__ __volatile__("");
856 if (wot == 284) return fn(info);
857 __asm__ __volatile__("");
858 if (wot == 285) return fn(info);
859 __asm__ __volatile__("");
860 if (wot == 286) return fn(info);
861 __asm__ __volatile__("");
862 if (wot == 287) return fn(info);
863 __asm__ __volatile__("");
864 if (wot == 288) return fn(info);
865 __asm__ __volatile__("");
866 if (wot == 289) return fn(info);
867 __asm__ __volatile__("");
868 if (wot == 290) return fn(info);
869 __asm__ __volatile__("");
870 if (wot == 291) return fn(info);
871 __asm__ __volatile__("");
872 if (wot == 292) return fn(info);
873 __asm__ __volatile__("");
874 if (wot == 293) return fn(info);
875 __asm__ __volatile__("");
876 if (wot == 294) return fn(info);
877 __asm__ __volatile__("");
878 if (wot == 295) return fn(info);
879 __asm__ __volatile__("");
880 if (wot == 296) return fn(info);
881 __asm__ __volatile__("");
882 if (wot == 297) return fn(info);
883 __asm__ __volatile__("");
884 if (wot == 298) return fn(info);
885 __asm__ __volatile__("");
886 if (wot == 299) return fn(info);
887 __asm__ __volatile__("");
888 if (wot == 300) return fn(info);
889 __asm__ __volatile__("");
890 if (wot == 301) return fn(info);
891 __asm__ __volatile__("");
892 if (wot == 302) return fn(info);
893 __asm__ __volatile__("");
894 if (wot == 303) return fn(info);
895 __asm__ __volatile__("");
896 if (wot == 304) return fn(info);
897 __asm__ __volatile__("");
898 if (wot == 305) return fn(info);
899 __asm__ __volatile__("");
900 if (wot == 306) return fn(info);
901 __asm__ __volatile__("");
902 if (wot == 307) return fn(info);
903 __asm__ __volatile__("");
904 if (wot == 308) return fn(info);
905 __asm__ __volatile__("");
906 if (wot == 309) return fn(info);
907 __asm__ __volatile__("");
908 if (wot == 310) return fn(info);
909 __asm__ __volatile__("");
910 if (wot == 311) return fn(info);
911 __asm__ __volatile__("");
912 if (wot == 312) return fn(info);
913 __asm__ __volatile__("");
914 if (wot == 313) return fn(info);
915 __asm__ __volatile__("");
916 if (wot == 314) return fn(info);
917 __asm__ __volatile__("");
918 if (wot == 315) return fn(info);
919 __asm__ __volatile__("");
920 if (wot == 316) return fn(info);
921 __asm__ __volatile__("");
922 if (wot == 317) return fn(info);
923 __asm__ __volatile__("");
924 if (wot == 318) return fn(info);
925 __asm__ __volatile__("");
926 if (wot == 319) return fn(info);
927 __asm__ __volatile__("");
928 if (wot == 320) return fn(info);
929 __asm__ __volatile__("");
930 if (wot == 321) return fn(info);
931 __asm__ __volatile__("");
932 if (wot == 322) return fn(info);
933 __asm__ __volatile__("");
934 if (wot == 323) return fn(info);
935 __asm__ __volatile__("");
936 if (wot == 324) return fn(info);
937 __asm__ __volatile__("");
938 if (wot == 325) return fn(info);
939 __asm__ __volatile__("");
940 if (wot == 326) return fn(info);
941 __asm__ __volatile__("");
942 if (wot == 327) return fn(info);
943 __asm__ __volatile__("");
944 if (wot == 328) return fn(info);
945 __asm__ __volatile__("");
946 if (wot == 329) return fn(info);
947 __asm__ __volatile__("");
948 if (wot == 330) return fn(info);
949 __asm__ __volatile__("");
950 if (wot == 331) return fn(info);
951 __asm__ __volatile__("");
952 if (wot == 332) return fn(info);
953 __asm__ __volatile__("");
954 if (wot == 333) return fn(info);
955 __asm__ __volatile__("");
956 if (wot == 334) return fn(info);
957 __asm__ __volatile__("");
958 if (wot == 335) return fn(info);
959 __asm__ __volatile__("");
960 if (wot == 336) return fn(info);
961 __asm__ __volatile__("");
962 if (wot == 337) return fn(info);
963 __asm__ __volatile__("");
964 if (wot == 338) return fn(info);
965 __asm__ __volatile__("");
966 if (wot == 339) return fn(info);
967 __asm__ __volatile__("");
968 if (wot == 340) return fn(info);
969 __asm__ __volatile__("");
970 if (wot == 341) return fn(info);
971 __asm__ __volatile__("");
972 if (wot == 342) return fn(info);
973 __asm__ __volatile__("");
974 if (wot == 343) return fn(info);
975 __asm__ __volatile__("");
976 if (wot == 344) return fn(info);
977 __asm__ __volatile__("");
978 if (wot == 345) return fn(info);
979 __asm__ __volatile__("");
980 if (wot == 346) return fn(info);
981 __asm__ __volatile__("");
982 if (wot == 347) return fn(info);
983 __asm__ __volatile__("");
984 if (wot == 348) return fn(info);
985 __asm__ __volatile__("");
986 if (wot == 349) return fn(info);
987 __asm__ __volatile__("");
988 if (wot == 350) return fn(info);
989 __asm__ __volatile__("");
990 if (wot == 351) return fn(info);
991 __asm__ __volatile__("");
992 if (wot == 352) return fn(info);
993 __asm__ __volatile__("");
994 if (wot == 353) return fn(info);
995 __asm__ __volatile__("");
996 if (wot == 354) return fn(info);
997 __asm__ __volatile__("");
998 if (wot == 355) return fn(info);
999 __asm__ __volatile__("");
1000 if (wot == 356) return fn(info);
1001 __asm__ __volatile__("");
1002 if (wot == 357) return fn(info);
1003 __asm__ __volatile__("");
1004 if (wot == 358) return fn(info);
1005 __asm__ __volatile__("");
1006 if (wot == 359) return fn(info);
1007 __asm__ __volatile__("");
1008 if (wot == 360) return fn(info);
1009 __asm__ __volatile__("");
1010 if (wot == 361) return fn(info);
1011 __asm__ __volatile__("");
1012 if (wot == 362) return fn(info);
1013 __asm__ __volatile__("");
1014 if (wot == 363) return fn(info);
1015 __asm__ __volatile__("");
1016 if (wot == 364) return fn(info);
1017 __asm__ __volatile__("");
1018 if (wot == 365) return fn(info);
1019 __asm__ __volatile__("");
1020 if (wot == 366) return fn(info);
1021 __asm__ __volatile__("");
1022 if (wot == 367) return fn(info);
1023 __asm__ __volatile__("");
1024 if (wot == 368) return fn(info);
1025 __asm__ __volatile__("");
1026 if (wot == 369) return fn(info);
1027 __asm__ __volatile__("");
1028 if (wot == 370) return fn(info);
1029 __asm__ __volatile__("");
1030 if (wot == 371) return fn(info);
1031 __asm__ __volatile__("");
1032 if (wot == 372) return fn(info);
1033 __asm__ __volatile__("");
1034 if (wot == 373) return fn(info);
1035 __asm__ __volatile__("");
1036 if (wot == 374) return fn(info);
1037 __asm__ __volatile__("");
1038 if (wot == 375) return fn(info);
1039 __asm__ __volatile__("");
1040 if (wot == 376) return fn(info);
1041 __asm__ __volatile__("");
1042 if (wot == 377) return fn(info);
1043 __asm__ __volatile__("");
1044 if (wot == 378) return fn(info);
1045 __asm__ __volatile__("");
1046 if (wot == 379) return fn(info);
1047 __asm__ __volatile__("");
1048 if (wot == 380) return fn(info);
1049 __asm__ __volatile__("");
1050 if (wot == 381) return fn(info);
1051 __asm__ __volatile__("");
1052 if (wot == 382) return fn(info);
1053 __asm__ __volatile__("");
1054 if (wot == 383) return fn(info);
1055 __asm__ __volatile__("");
1056 if (wot == 384) return fn(info);
1057 __asm__ __volatile__("");
1058 if (wot == 385) return fn(info);
1059 __asm__ __volatile__("");
1060 if (wot == 386) return fn(info);
1061 __asm__ __volatile__("");
1062 if (wot == 387) return fn(info);
1063 __asm__ __volatile__("");
1064 if (wot == 388) return fn(info);
1065 __asm__ __volatile__("");
1066 if (wot == 389) return fn(info);
1067 __asm__ __volatile__("");
1068 if (wot == 390) return fn(info);
1069 __asm__ __volatile__("");
1070 if (wot == 391) return fn(info);
1071 __asm__ __volatile__("");
1072 if (wot == 392) return fn(info);
1073 __asm__ __volatile__("");
1074 if (wot == 393) return fn(info);
1075 __asm__ __volatile__("");
1076 if (wot == 394) return fn(info);
1077 __asm__ __volatile__("");
1078 if (wot == 395) return fn(info);
1079 __asm__ __volatile__("");
1080 if (wot == 396) return fn(info);
1081 __asm__ __volatile__("");
1082 if (wot == 397) return fn(info);
1083 __asm__ __volatile__("");
1084 if (wot == 398) return fn(info);
1085 __asm__ __volatile__("");
1086 if (wot == 399) return fn(info);
1087 __asm__ __volatile__("");
1088 if (wot == 400) return fn(info);
1089 __asm__ __volatile__("");
1090 if (wot == 401) return fn(info);
1091 __asm__ __volatile__("");
1092 if (wot == 402) return fn(info);
1093 __asm__ __volatile__("");
1094 if (wot == 403) return fn(info);
1095 __asm__ __volatile__("");
1096 if (wot == 404) return fn(info);
1097 __asm__ __volatile__("");
1098 if (wot == 405) return fn(info);
1099 __asm__ __volatile__("");
1100 if (wot == 406) return fn(info);
1101 __asm__ __volatile__("");
1102 if (wot == 407) return fn(info);
1103 __asm__ __volatile__("");
1104 if (wot == 408) return fn(info);
1105 __asm__ __volatile__("");
1106 if (wot == 409) return fn(info);
1107 __asm__ __volatile__("");
1108 if (wot == 410) return fn(info);
1109 __asm__ __volatile__("");
1110 if (wot == 411) return fn(info);
1111 __asm__ __volatile__("");
1112 if (wot == 412) return fn(info);
1113 __asm__ __volatile__("");
1114 if (wot == 413) return fn(info);
1115 __asm__ __volatile__("");
1116 if (wot == 414) return fn(info);
1117 __asm__ __volatile__("");
1118 if (wot == 415) return fn(info);
1119 __asm__ __volatile__("");
1120 if (wot == 416) return fn(info);
1121 __asm__ __volatile__("");
1122 if (wot == 417) return fn(info);
1123 __asm__ __volatile__("");
1124 if (wot == 418) return fn(info);
1125 __asm__ __volatile__("");
1126 if (wot == 419) return fn(info);
1127 __asm__ __volatile__("");
1128 if (wot == 420) return fn(info);
1129 __asm__ __volatile__("");
1130 if (wot == 421) return fn(info);
1131 __asm__ __volatile__("");
1132 if (wot == 422) return fn(info);
1133 __asm__ __volatile__("");
1134 if (wot == 423) return fn(info);
1135 __asm__ __volatile__("");
1136 if (wot == 424) return fn(info);
1137 __asm__ __volatile__("");
1138 if (wot == 425) return fn(info);
1139 __asm__ __volatile__("");
1140 if (wot == 426) return fn(info);
1141 __asm__ __volatile__("");
1142 if (wot == 427) return fn(info);
1143 __asm__ __volatile__("");
1144 if (wot == 428) return fn(info);
1145 __asm__ __volatile__("");
1146 if (wot == 429) return fn(info);
1147 __asm__ __volatile__("");
1148 if (wot == 430) return fn(info);
1149 __asm__ __volatile__("");
1150 if (wot == 431) return fn(info);
1151 __asm__ __volatile__("");
1152 if (wot == 432) return fn(info);
1153 __asm__ __volatile__("");
1154 if (wot == 433) return fn(info);
1155 __asm__ __volatile__("");
1156 if (wot == 434) return fn(info);
1157 __asm__ __volatile__("");
1158 if (wot == 435) return fn(info);
1159 __asm__ __volatile__("");
1160 if (wot == 436) return fn(info);
1161 __asm__ __volatile__("");
1162 if (wot == 437) return fn(info);
1163 __asm__ __volatile__("");
1164 if (wot == 438) return fn(info);
1165 __asm__ __volatile__("");
1166 if (wot == 439) return fn(info);
1167 __asm__ __volatile__("");
1168 if (wot == 440) return fn(info);
1169 __asm__ __volatile__("");
1170 if (wot == 441) return fn(info);
1171 __asm__ __volatile__("");
1172 if (wot == 442) return fn(info);
1173 __asm__ __volatile__("");
1174 if (wot == 443) return fn(info);
1175 __asm__ __volatile__("");
1176 if (wot == 444) return fn(info);
1177 __asm__ __volatile__("");
1178 if (wot == 445) return fn(info);
1179 __asm__ __volatile__("");
1180 if (wot == 446) return fn(info);
1181 __asm__ __volatile__("");
1182 if (wot == 447) return fn(info);
1183 __asm__ __volatile__("");
1184 if (wot == 448) return fn(info);
1185 __asm__ __volatile__("");
1186 if (wot == 449) return fn(info);
1187 __asm__ __volatile__("");
1188 if (wot == 450) return fn(info);
1189 __asm__ __volatile__("");
1190 if (wot == 451) return fn(info);
1191 __asm__ __volatile__("");
1192 if (wot == 452) return fn(info);
1193 __asm__ __volatile__("");
1194 if (wot == 453) return fn(info);
1195 __asm__ __volatile__("");
1196 if (wot == 454) return fn(info);
1197 __asm__ __volatile__("");
1198 if (wot == 455) return fn(info);
1199 __asm__ __volatile__("");
1200 if (wot == 456) return fn(info);
1201 __asm__ __volatile__("");
1202 if (wot == 457) return fn(info);
1203 __asm__ __volatile__("");
1204 if (wot == 458) return fn(info);
1205 __asm__ __volatile__("");
1206 if (wot == 459) return fn(info);
1207 __asm__ __volatile__("");
1208 if (wot == 460) return fn(info);
1209 __asm__ __volatile__("");
1210 if (wot == 461) return fn(info);
1211 __asm__ __volatile__("");
1212 if (wot == 462) return fn(info);
1213 __asm__ __volatile__("");
1214 if (wot == 463) return fn(info);
1215 __asm__ __volatile__("");
1216 if (wot == 464) return fn(info);
1217 __asm__ __volatile__("");
1218 if (wot == 465) return fn(info);
1219 __asm__ __volatile__("");
1220 if (wot == 466) return fn(info);
1221 __asm__ __volatile__("");
1222 if (wot == 467) return fn(info);
1223 __asm__ __volatile__("");
1224 if (wot == 468) return fn(info);
1225 __asm__ __volatile__("");
1226 if (wot == 469) return fn(info);
1227 __asm__ __volatile__("");
1228 if (wot == 470) return fn(info);
1229 __asm__ __volatile__("");
1230 if (wot == 471) return fn(info);
1231 __asm__ __volatile__("");
1232 if (wot == 472) return fn(info);
1233 __asm__ __volatile__("");
1234 if (wot == 473) return fn(info);
1235 __asm__ __volatile__("");
1236 if (wot == 474) return fn(info);
1237 __asm__ __volatile__("");
1238 if (wot == 475) return fn(info);
1239 __asm__ __volatile__("");
1240 if (wot == 476) return fn(info);
1241 __asm__ __volatile__("");
1242 if (wot == 477) return fn(info);
1243 __asm__ __volatile__("");
1244 if (wot == 478) return fn(info);
1245 __asm__ __volatile__("");
1246 if (wot == 479) return fn(info);
1247 __asm__ __volatile__("");
1248 if (wot == 480) return fn(info);
1249 __asm__ __volatile__("");
1250 if (wot == 481) return fn(info);
1251 __asm__ __volatile__("");
1252 if (wot == 482) return fn(info);
1253 __asm__ __volatile__("");
1254 if (wot == 483) return fn(info);
1255 __asm__ __volatile__("");
1256 if (wot == 484) return fn(info);
1257 __asm__ __volatile__("");
1258 if (wot == 485) return fn(info);
1259 __asm__ __volatile__("");
1260 if (wot == 486) return fn(info);
1261 __asm__ __volatile__("");
1262 if (wot == 487) return fn(info);
1263 __asm__ __volatile__("");
1264 if (wot == 488) return fn(info);
1265 __asm__ __volatile__("");
1266 if (wot == 489) return fn(info);
1267 __asm__ __volatile__("");
1268 if (wot == 490) return fn(info);
1269 __asm__ __volatile__("");
1270 if (wot == 491) return fn(info);
1271 __asm__ __volatile__("");
1272 if (wot == 492) return fn(info);
1273 __asm__ __volatile__("");
1274 if (wot == 493) return fn(info);
1275 __asm__ __volatile__("");
1276 if (wot == 494) return fn(info);
1277 __asm__ __volatile__("");
1278 if (wot == 495) return fn(info);
1279 __asm__ __volatile__("");
1280 if (wot == 496) return fn(info);
1281 __asm__ __volatile__("");
1282 if (wot == 497) return fn(info);
1283 __asm__ __volatile__("");
1284 if (wot == 498) return fn(info);
1285 __asm__ __volatile__("");
1286 if (wot == 499) return fn(info);
1287 __asm__ __volatile__("");
1288 halfway:
1289 if (wot == 500) return fn(info);
1290 __asm__ __volatile__("");
1291 if (wot == 501) return fn(info);
1292 __asm__ __volatile__("");
1293 if (wot == 502) return fn(info);
1294 __asm__ __volatile__("");
1295 if (wot == 503) return fn(info);
1296 __asm__ __volatile__("");
1297 if (wot == 504) return fn(info);
1298 __asm__ __volatile__("");
1299 if (wot == 505) return fn(info);
1300 __asm__ __volatile__("");
1301 if (wot == 506) return fn(info);
1302 __asm__ __volatile__("");
1303 if (wot == 507) return fn(info);
1304 __asm__ __volatile__("");
1305 if (wot == 508) return fn(info);
1306 __asm__ __volatile__("");
1307 if (wot == 509) return fn(info);
1308 __asm__ __volatile__("");
1309 if (wot == 510) return fn(info);
1310 __asm__ __volatile__("");
1311 if (wot == 511) return fn(info);
1312 __asm__ __volatile__("");
1313 if (wot == 512) return fn(info);
1314 __asm__ __volatile__("");
1315 if (wot == 513) return fn(info);
1316 __asm__ __volatile__("");
1317 if (wot == 514) return fn(info);
1318 __asm__ __volatile__("");
1319 if (wot == 515) return fn(info);
1320 __asm__ __volatile__("");
1321 if (wot == 516) return fn(info);
1322 __asm__ __volatile__("");
1323 if (wot == 517) return fn(info);
1324 __asm__ __volatile__("");
1325 if (wot == 518) return fn(info);
1326 __asm__ __volatile__("");
1327 if (wot == 519) return fn(info);
1328 __asm__ __volatile__("");
1329 if (wot == 520) return fn(info);
1330 __asm__ __volatile__("");
1331 if (wot == 521) return fn(info);
1332 __asm__ __volatile__("");
1333 if (wot == 522) return fn(info);
1334 __asm__ __volatile__("");
1335 if (wot == 523) return fn(info);
1336 __asm__ __volatile__("");
1337 if (wot == 524) return fn(info);
1338 __asm__ __volatile__("");
1339 if (wot == 525) return fn(info);
1340 __asm__ __volatile__("");
1341 if (wot == 526) return fn(info);
1342 __asm__ __volatile__("");
1343 if (wot == 527) return fn(info);
1344 __asm__ __volatile__("");
1345 if (wot == 528) return fn(info);
1346 __asm__ __volatile__("");
1347 if (wot == 529) return fn(info);
1348 __asm__ __volatile__("");
1349 if (wot == 530) return fn(info);
1350 __asm__ __volatile__("");
1351 if (wot == 531) return fn(info);
1352 __asm__ __volatile__("");
1353 if (wot == 532) return fn(info);
1354 __asm__ __volatile__("");
1355 if (wot == 533) return fn(info);
1356 __asm__ __volatile__("");
1357 if (wot == 534) return fn(info);
1358 __asm__ __volatile__("");
1359 if (wot == 535) return fn(info);
1360 __asm__ __volatile__("");
1361 if (wot == 536) return fn(info);
1362 __asm__ __volatile__("");
1363 if (wot == 537) return fn(info);
1364 __asm__ __volatile__("");
1365 if (wot == 538) return fn(info);
1366 __asm__ __volatile__("");
1367 if (wot == 539) return fn(info);
1368 __asm__ __volatile__("");
1369 if (wot == 540) return fn(info);
1370 __asm__ __volatile__("");
1371 if (wot == 541) return fn(info);
1372 __asm__ __volatile__("");
1373 if (wot == 542) return fn(info);
1374 __asm__ __volatile__("");
1375 if (wot == 543) return fn(info);
1376 __asm__ __volatile__("");
1377 if (wot == 544) return fn(info);
1378 __asm__ __volatile__("");
1379 if (wot == 545) return fn(info);
1380 __asm__ __volatile__("");
1381 if (wot == 546) return fn(info);
1382 __asm__ __volatile__("");
1383 if (wot == 547) return fn(info);
1384 __asm__ __volatile__("");
1385 if (wot == 548) return fn(info);
1386 __asm__ __volatile__("");
1387 if (wot == 549) return fn(info);
1388 __asm__ __volatile__("");
1389 if (wot == 550) return fn(info);
1390 __asm__ __volatile__("");
1391 if (wot == 551) return fn(info);
1392 __asm__ __volatile__("");
1393 if (wot == 552) return fn(info);
1394 __asm__ __volatile__("");
1395 if (wot == 553) return fn(info);
1396 __asm__ __volatile__("");
1397 if (wot == 554) return fn(info);
1398 __asm__ __volatile__("");
1399 if (wot == 555) return fn(info);
1400 __asm__ __volatile__("");
1401 if (wot == 556) return fn(info);
1402 __asm__ __volatile__("");
1403 if (wot == 557) return fn(info);
1404 __asm__ __volatile__("");
1405 if (wot == 558) return fn(info);
1406 __asm__ __volatile__("");
1407 if (wot == 559) return fn(info);
1408 __asm__ __volatile__("");
1409 if (wot == 560) return fn(info);
1410 __asm__ __volatile__("");
1411 if (wot == 561) return fn(info);
1412 __asm__ __volatile__("");
1413 if (wot == 562) return fn(info);
1414 __asm__ __volatile__("");
1415 if (wot == 563) return fn(info);
1416 __asm__ __volatile__("");
1417 if (wot == 564) return fn(info);
1418 __asm__ __volatile__("");
1419 if (wot == 565) return fn(info);
1420 __asm__ __volatile__("");
1421 if (wot == 566) return fn(info);
1422 __asm__ __volatile__("");
1423 if (wot == 567) return fn(info);
1424 __asm__ __volatile__("");
1425 if (wot == 568) return fn(info);
1426 __asm__ __volatile__("");
1427 if (wot == 569) return fn(info);
1428 __asm__ __volatile__("");
1429 if (wot == 570) return fn(info);
1430 __asm__ __volatile__("");
1431 if (wot == 571) return fn(info);
1432 __asm__ __volatile__("");
1433 if (wot == 572) return fn(info);
1434 __asm__ __volatile__("");
1435 if (wot == 573) return fn(info);
1436 __asm__ __volatile__("");
1437 if (wot == 574) return fn(info);
1438 __asm__ __volatile__("");
1439 if (wot == 575) return fn(info);
1440 __asm__ __volatile__("");
1441 if (wot == 576) return fn(info);
1442 __asm__ __volatile__("");
1443 if (wot == 577) return fn(info);
1444 __asm__ __volatile__("");
1445 if (wot == 578) return fn(info);
1446 __asm__ __volatile__("");
1447 if (wot == 579) return fn(info);
1448 __asm__ __volatile__("");
1449 if (wot == 580) return fn(info);
1450 __asm__ __volatile__("");
1451 if (wot == 581) return fn(info);
1452 __asm__ __volatile__("");
1453 if (wot == 582) return fn(info);
1454 __asm__ __volatile__("");
1455 if (wot == 583) return fn(info);
1456 __asm__ __volatile__("");
1457 if (wot == 584) return fn(info);
1458 __asm__ __volatile__("");
1459 if (wot == 585) return fn(info);
1460 __asm__ __volatile__("");
1461 if (wot == 586) return fn(info);
1462 __asm__ __volatile__("");
1463 if (wot == 587) return fn(info);
1464 __asm__ __volatile__("");
1465 if (wot == 588) return fn(info);
1466 __asm__ __volatile__("");
1467 if (wot == 589) return fn(info);
1468 __asm__ __volatile__("");
1469 if (wot == 590) return fn(info);
1470 __asm__ __volatile__("");
1471 if (wot == 591) return fn(info);
1472 __asm__ __volatile__("");
1473 if (wot == 592) return fn(info);
1474 __asm__ __volatile__("");
1475 if (wot == 593) return fn(info);
1476 __asm__ __volatile__("");
1477 if (wot == 594) return fn(info);
1478 __asm__ __volatile__("");
1479 if (wot == 595) return fn(info);
1480 __asm__ __volatile__("");
1481 if (wot == 596) return fn(info);
1482 __asm__ __volatile__("");
1483 if (wot == 597) return fn(info);
1484 __asm__ __volatile__("");
1485 if (wot == 598) return fn(info);
1486 __asm__ __volatile__("");
1487 if (wot == 599) return fn(info);
1488 __asm__ __volatile__("");
1489 if (wot == 600) return fn(info);
1490 __asm__ __volatile__("");
1491 if (wot == 601) return fn(info);
1492 __asm__ __volatile__("");
1493 if (wot == 602) return fn(info);
1494 __asm__ __volatile__("");
1495 if (wot == 603) return fn(info);
1496 __asm__ __volatile__("");
1497 if (wot == 604) return fn(info);
1498 __asm__ __volatile__("");
1499 if (wot == 605) return fn(info);
1500 __asm__ __volatile__("");
1501 if (wot == 606) return fn(info);
1502 __asm__ __volatile__("");
1503 if (wot == 607) return fn(info);
1504 __asm__ __volatile__("");
1505 if (wot == 608) return fn(info);
1506 __asm__ __volatile__("");
1507 if (wot == 609) return fn(info);
1508 __asm__ __volatile__("");
1509 if (wot == 610) return fn(info);
1510 __asm__ __volatile__("");
1511 if (wot == 611) return fn(info);
1512 __asm__ __volatile__("");
1513 if (wot == 612) return fn(info);
1514 __asm__ __volatile__("");
1515 if (wot == 613) return fn(info);
1516 __asm__ __volatile__("");
1517 if (wot == 614) return fn(info);
1518 __asm__ __volatile__("");
1519 if (wot == 615) return fn(info);
1520 __asm__ __volatile__("");
1521 if (wot == 616) return fn(info);
1522 __asm__ __volatile__("");
1523 if (wot == 617) return fn(info);
1524 __asm__ __volatile__("");
1525 if (wot == 618) return fn(info);
1526 __asm__ __volatile__("");
1527 if (wot == 619) return fn(info);
1528 __asm__ __volatile__("");
1529 if (wot == 620) return fn(info);
1530 __asm__ __volatile__("");
1531 if (wot == 621) return fn(info);
1532 __asm__ __volatile__("");
1533 if (wot == 622) return fn(info);
1534 __asm__ __volatile__("");
1535 if (wot == 623) return fn(info);
1536 __asm__ __volatile__("");
1537 if (wot == 624) return fn(info);
1538 __asm__ __volatile__("");
1539 if (wot == 625) return fn(info);
1540 __asm__ __volatile__("");
1541 if (wot == 626) return fn(info);
1542 __asm__ __volatile__("");
1543 if (wot == 627) return fn(info);
1544 __asm__ __volatile__("");
1545 if (wot == 628) return fn(info);
1546 __asm__ __volatile__("");
1547 if (wot == 629) return fn(info);
1548 __asm__ __volatile__("");
1549 if (wot == 630) return fn(info);
1550 __asm__ __volatile__("");
1551 if (wot == 631) return fn(info);
1552 __asm__ __volatile__("");
1553 if (wot == 632) return fn(info);
1554 __asm__ __volatile__("");
1555 if (wot == 633) return fn(info);
1556 __asm__ __volatile__("");
1557 if (wot == 634) return fn(info);
1558 __asm__ __volatile__("");
1559 if (wot == 635) return fn(info);
1560 __asm__ __volatile__("");
1561 if (wot == 636) return fn(info);
1562 __asm__ __volatile__("");
1563 if (wot == 637) return fn(info);
1564 __asm__ __volatile__("");
1565 if (wot == 638) return fn(info);
1566 __asm__ __volatile__("");
1567 if (wot == 639) return fn(info);
1568 __asm__ __volatile__("");
1569 if (wot == 640) return fn(info);
1570 __asm__ __volatile__("");
1571 if (wot == 641) return fn(info);
1572 __asm__ __volatile__("");
1573 if (wot == 642) return fn(info);
1574 __asm__ __volatile__("");
1575 if (wot == 643) return fn(info);
1576 __asm__ __volatile__("");
1577 if (wot == 644) return fn(info);
1578 __asm__ __volatile__("");
1579 if (wot == 645) return fn(info);
1580 __asm__ __volatile__("");
1581 if (wot == 646) return fn(info);
1582 __asm__ __volatile__("");
1583 if (wot == 647) return fn(info);
1584 __asm__ __volatile__("");
1585 if (wot == 648) return fn(info);
1586 __asm__ __volatile__("");
1587 if (wot == 649) return fn(info);
1588 __asm__ __volatile__("");
1589 if (wot == 650) return fn(info);
1590 __asm__ __volatile__("");
1591 if (wot == 651) return fn(info);
1592 __asm__ __volatile__("");
1593 if (wot == 652) return fn(info);
1594 __asm__ __volatile__("");
1595 if (wot == 653) return fn(info);
1596 __asm__ __volatile__("");
1597 if (wot == 654) return fn(info);
1598 __asm__ __volatile__("");
1599 if (wot == 655) return fn(info);
1600 __asm__ __volatile__("");
1601 if (wot == 656) return fn(info);
1602 __asm__ __volatile__("");
1603 if (wot == 657) return fn(info);
1604 __asm__ __volatile__("");
1605 if (wot == 658) return fn(info);
1606 __asm__ __volatile__("");
1607 if (wot == 659) return fn(info);
1608 __asm__ __volatile__("");
1609 if (wot == 660) return fn(info);
1610 __asm__ __volatile__("");
1611 if (wot == 661) return fn(info);
1612 __asm__ __volatile__("");
1613 if (wot == 662) return fn(info);
1614 __asm__ __volatile__("");
1615 if (wot == 663) return fn(info);
1616 __asm__ __volatile__("");
1617 if (wot == 664) return fn(info);
1618 __asm__ __volatile__("");
1619 if (wot == 665) return fn(info);
1620 __asm__ __volatile__("");
1621 if (wot == 666) return fn(info);
1622 __asm__ __volatile__("");
1623 if (wot == 667) return fn(info);
1624 __asm__ __volatile__("");
1625 if (wot == 668) return fn(info);
1626 __asm__ __volatile__("");
1627 if (wot == 669) return fn(info);
1628 __asm__ __volatile__("");
1629 if (wot == 670) return fn(info);
1630 __asm__ __volatile__("");
1631 if (wot == 671) return fn(info);
1632 __asm__ __volatile__("");
1633 if (wot == 672) return fn(info);
1634 __asm__ __volatile__("");
1635 if (wot == 673) return fn(info);
1636 __asm__ __volatile__("");
1637 if (wot == 674) return fn(info);
1638 __asm__ __volatile__("");
1639 if (wot == 675) return fn(info);
1640 __asm__ __volatile__("");
1641 if (wot == 676) return fn(info);
1642 __asm__ __volatile__("");
1643 if (wot == 677) return fn(info);
1644 __asm__ __volatile__("");
1645 if (wot == 678) return fn(info);
1646 __asm__ __volatile__("");
1647 if (wot == 679) return fn(info);
1648 __asm__ __volatile__("");
1649 if (wot == 680) return fn(info);
1650 __asm__ __volatile__("");
1651 if (wot == 681) return fn(info);
1652 __asm__ __volatile__("");
1653 if (wot == 682) return fn(info);
1654 __asm__ __volatile__("");
1655 if (wot == 683) return fn(info);
1656 __asm__ __volatile__("");
1657 if (wot == 684) return fn(info);
1658 __asm__ __volatile__("");
1659 if (wot == 685) return fn(info);
1660 __asm__ __volatile__("");
1661 if (wot == 686) return fn(info);
1662 __asm__ __volatile__("");
1663 if (wot == 687) return fn(info);
1664 __asm__ __volatile__("");
1665 if (wot == 688) return fn(info);
1666 __asm__ __volatile__("");
1667 if (wot == 689) return fn(info);
1668 __asm__ __volatile__("");
1669 if (wot == 690) return fn(info);
1670 __asm__ __volatile__("");
1671 if (wot == 691) return fn(info);
1672 __asm__ __volatile__("");
1673 if (wot == 692) return fn(info);
1674 __asm__ __volatile__("");
1675 if (wot == 693) return fn(info);
1676 __asm__ __volatile__("");
1677 if (wot == 694) return fn(info);
1678 __asm__ __volatile__("");
1679 if (wot == 695) return fn(info);
1680 __asm__ __volatile__("");
1681 if (wot == 696) return fn(info);
1682 __asm__ __volatile__("");
1683 if (wot == 697) return fn(info);
1684 __asm__ __volatile__("");
1685 if (wot == 698) return fn(info);
1686 __asm__ __volatile__("");
1687 if (wot == 699) return fn(info);
1688 __asm__ __volatile__("");
1689 if (wot == 700) return fn(info);
1690 __asm__ __volatile__("");
1691 if (wot == 701) return fn(info);
1692 __asm__ __volatile__("");
1693 if (wot == 702) return fn(info);
1694 __asm__ __volatile__("");
1695 if (wot == 703) return fn(info);
1696 __asm__ __volatile__("");
1697 if (wot == 704) return fn(info);
1698 __asm__ __volatile__("");
1699 if (wot == 705) return fn(info);
1700 __asm__ __volatile__("");
1701 if (wot == 706) return fn(info);
1702 __asm__ __volatile__("");
1703 if (wot == 707) return fn(info);
1704 __asm__ __volatile__("");
1705 if (wot == 708) return fn(info);
1706 __asm__ __volatile__("");
1707 if (wot == 709) return fn(info);
1708 __asm__ __volatile__("");
1709 if (wot == 710) return fn(info);
1710 __asm__ __volatile__("");
1711 if (wot == 711) return fn(info);
1712 __asm__ __volatile__("");
1713 if (wot == 712) return fn(info);
1714 __asm__ __volatile__("");
1715 if (wot == 713) return fn(info);
1716 __asm__ __volatile__("");
1717 if (wot == 714) return fn(info);
1718 __asm__ __volatile__("");
1719 if (wot == 715) return fn(info);
1720 __asm__ __volatile__("");
1721 if (wot == 716) return fn(info);
1722 __asm__ __volatile__("");
1723 if (wot == 717) return fn(info);
1724 __asm__ __volatile__("");
1725 if (wot == 718) return fn(info);
1726 __asm__ __volatile__("");
1727 if (wot == 719) return fn(info);
1728 __asm__ __volatile__("");
1729 if (wot == 720) return fn(info);
1730 __asm__ __volatile__("");
1731 if (wot == 721) return fn(info);
1732 __asm__ __volatile__("");
1733 if (wot == 722) return fn(info);
1734 __asm__ __volatile__("");
1735 if (wot == 723) return fn(info);
1736 __asm__ __volatile__("");
1737 if (wot == 724) return fn(info);
1738 __asm__ __volatile__("");
1739 if (wot == 725) return fn(info);
1740 __asm__ __volatile__("");
1741 if (wot == 726) return fn(info);
1742 __asm__ __volatile__("");
1743 if (wot == 727) return fn(info);
1744 __asm__ __volatile__("");
1745 if (wot == 728) return fn(info);
1746 __asm__ __volatile__("");
1747 if (wot == 729) return fn(info);
1748 __asm__ __volatile__("");
1749 if (wot == 730) return fn(info);
1750 __asm__ __volatile__("");
1751 if (wot == 731) return fn(info);
1752 __asm__ __volatile__("");
1753 if (wot == 732) return fn(info);
1754 __asm__ __volatile__("");
1755 if (wot == 733) return fn(info);
1756 __asm__ __volatile__("");
1757 if (wot == 734) return fn(info);
1758 __asm__ __volatile__("");
1759 if (wot == 735) return fn(info);
1760 __asm__ __volatile__("");
1761 if (wot == 736) return fn(info);
1762 __asm__ __volatile__("");
1763 if (wot == 737) return fn(info);
1764 __asm__ __volatile__("");
1765 if (wot == 738) return fn(info);
1766 __asm__ __volatile__("");
1767 if (wot == 739) return fn(info);
1768 __asm__ __volatile__("");
1769 if (wot == 740) return fn(info);
1770 __asm__ __volatile__("");
1771 if (wot == 741) return fn(info);
1772 __asm__ __volatile__("");
1773 if (wot == 742) return fn(info);
1774 __asm__ __volatile__("");
1775 if (wot == 743) return fn(info);
1776 __asm__ __volatile__("");
1777 if (wot == 744) return fn(info);
1778 __asm__ __volatile__("");
1779 if (wot == 745) return fn(info);
1780 __asm__ __volatile__("");
1781 if (wot == 746) return fn(info);
1782 __asm__ __volatile__("");
1783 if (wot == 747) return fn(info);
1784 __asm__ __volatile__("");
1785 if (wot == 748) return fn(info);
1786 __asm__ __volatile__("");
1787 if (wot == 749) return fn(info);
1788 __asm__ __volatile__("");
1789 if (wot == 750) return fn(info);
1790 __asm__ __volatile__("");
1791 if (wot == 751) return fn(info);
1792 __asm__ __volatile__("");
1793 if (wot == 752) return fn(info);
1794 __asm__ __volatile__("");
1795 if (wot == 753) return fn(info);
1796 __asm__ __volatile__("");
1797 if (wot == 754) return fn(info);
1798 __asm__ __volatile__("");
1799 if (wot == 755) return fn(info);
1800 __asm__ __volatile__("");
1801 if (wot == 756) return fn(info);
1802 __asm__ __volatile__("");
1803 if (wot == 757) return fn(info);
1804 __asm__ __volatile__("");
1805 if (wot == 758) return fn(info);
1806 __asm__ __volatile__("");
1807 if (wot == 759) return fn(info);
1808 __asm__ __volatile__("");
1809 if (wot == 760) return fn(info);
1810 __asm__ __volatile__("");
1811 if (wot == 761) return fn(info);
1812 __asm__ __volatile__("");
1813 if (wot == 762) return fn(info);
1814 __asm__ __volatile__("");
1815 if (wot == 763) return fn(info);
1816 __asm__ __volatile__("");
1817 if (wot == 764) return fn(info);
1818 __asm__ __volatile__("");
1819 if (wot == 765) return fn(info);
1820 __asm__ __volatile__("");
1821 if (wot == 766) return fn(info);
1822 __asm__ __volatile__("");
1823 if (wot == 767) return fn(info);
1824 __asm__ __volatile__("");
1825 if (wot == 768) return fn(info);
1826 __asm__ __volatile__("");
1827 if (wot == 769) return fn(info);
1828 __asm__ __volatile__("");
1829 if (wot == 770) return fn(info);
1830 __asm__ __volatile__("");
1831 if (wot == 771) return fn(info);
1832 __asm__ __volatile__("");
1833 if (wot == 772) return fn(info);
1834 __asm__ __volatile__("");
1835 if (wot == 773) return fn(info);
1836 __asm__ __volatile__("");
1837 if (wot == 774) return fn(info);
1838 __asm__ __volatile__("");
1839 if (wot == 775) return fn(info);
1840 __asm__ __volatile__("");
1841 if (wot == 776) return fn(info);
1842 __asm__ __volatile__("");
1843 if (wot == 777) return fn(info);
1844 __asm__ __volatile__("");
1845 if (wot == 778) return fn(info);
1846 __asm__ __volatile__("");
1847 if (wot == 779) return fn(info);
1848 __asm__ __volatile__("");
1849 if (wot == 780) return fn(info);
1850 __asm__ __volatile__("");
1851 if (wot == 781) return fn(info);
1852 __asm__ __volatile__("");
1853 if (wot == 782) return fn(info);
1854 __asm__ __volatile__("");
1855 if (wot == 783) return fn(info);
1856 __asm__ __volatile__("");
1857 if (wot == 784) return fn(info);
1858 __asm__ __volatile__("");
1859 if (wot == 785) return fn(info);
1860 __asm__ __volatile__("");
1861 if (wot == 786) return fn(info);
1862 __asm__ __volatile__("");
1863 if (wot == 787) return fn(info);
1864 __asm__ __volatile__("");
1865 if (wot == 788) return fn(info);
1866 __asm__ __volatile__("");
1867 if (wot == 789) return fn(info);
1868 __asm__ __volatile__("");
1869 if (wot == 790) return fn(info);
1870 __asm__ __volatile__("");
1871 if (wot == 791) return fn(info);
1872 __asm__ __volatile__("");
1873 if (wot == 792) return fn(info);
1874 __asm__ __volatile__("");
1875 if (wot == 793) return fn(info);
1876 __asm__ __volatile__("");
1877 if (wot == 794) return fn(info);
1878 __asm__ __volatile__("");
1879 if (wot == 795) return fn(info);
1880 __asm__ __volatile__("");
1881 if (wot == 796) return fn(info);
1882 __asm__ __volatile__("");
1883 if (wot == 797) return fn(info);
1884 __asm__ __volatile__("");
1885 if (wot == 798) return fn(info);
1886 __asm__ __volatile__("");
1887 if (wot == 799) return fn(info);
1888 __asm__ __volatile__("");
1889 if (wot == 800) return fn(info);
1890 __asm__ __volatile__("");
1891 if (wot == 801) return fn(info);
1892 __asm__ __volatile__("");
1893 if (wot == 802) return fn(info);
1894 __asm__ __volatile__("");
1895 if (wot == 803) return fn(info);
1896 __asm__ __volatile__("");
1897 if (wot == 804) return fn(info);
1898 __asm__ __volatile__("");
1899 if (wot == 805) return fn(info);
1900 __asm__ __volatile__("");
1901 if (wot == 806) return fn(info);
1902 __asm__ __volatile__("");
1903 if (wot == 807) return fn(info);
1904 __asm__ __volatile__("");
1905 if (wot == 808) return fn(info);
1906 __asm__ __volatile__("");
1907 if (wot == 809) return fn(info);
1908 __asm__ __volatile__("");
1909 if (wot == 810) return fn(info);
1910 __asm__ __volatile__("");
1911 if (wot == 811) return fn(info);
1912 __asm__ __volatile__("");
1913 if (wot == 812) return fn(info);
1914 __asm__ __volatile__("");
1915 if (wot == 813) return fn(info);
1916 __asm__ __volatile__("");
1917 if (wot == 814) return fn(info);
1918 __asm__ __volatile__("");
1919 if (wot == 815) return fn(info);
1920 __asm__ __volatile__("");
1921 if (wot == 816) return fn(info);
1922 __asm__ __volatile__("");
1923 if (wot == 817) return fn(info);
1924 __asm__ __volatile__("");
1925 if (wot == 818) return fn(info);
1926 __asm__ __volatile__("");
1927 if (wot == 819) return fn(info);
1928 __asm__ __volatile__("");
1929 if (wot == 820) return fn(info);
1930 __asm__ __volatile__("");
1931 if (wot == 821) return fn(info);
1932 __asm__ __volatile__("");
1933 if (wot == 822) return fn(info);
1934 __asm__ __volatile__("");
1935 if (wot == 823) return fn(info);
1936 __asm__ __volatile__("");
1937 if (wot == 824) return fn(info);
1938 __asm__ __volatile__("");
1939 if (wot == 825) return fn(info);
1940 __asm__ __volatile__("");
1941 if (wot == 826) return fn(info);
1942 __asm__ __volatile__("");
1943 if (wot == 827) return fn(info);
1944 __asm__ __volatile__("");
1945 if (wot == 828) return fn(info);
1946 __asm__ __volatile__("");
1947 if (wot == 829) return fn(info);
1948 __asm__ __volatile__("");
1949 if (wot == 830) return fn(info);
1950 __asm__ __volatile__("");
1951 if (wot == 831) return fn(info);
1952 __asm__ __volatile__("");
1953 if (wot == 832) return fn(info);
1954 __asm__ __volatile__("");
1955 if (wot == 833) return fn(info);
1956 __asm__ __volatile__("");
1957 if (wot == 834) return fn(info);
1958 __asm__ __volatile__("");
1959 if (wot == 835) return fn(info);
1960 __asm__ __volatile__("");
1961 if (wot == 836) return fn(info);
1962 __asm__ __volatile__("");
1963 if (wot == 837) return fn(info);
1964 __asm__ __volatile__("");
1965 if (wot == 838) return fn(info);
1966 __asm__ __volatile__("");
1967 if (wot == 839) return fn(info);
1968 __asm__ __volatile__("");
1969 if (wot == 840) return fn(info);
1970 __asm__ __volatile__("");
1971 if (wot == 841) return fn(info);
1972 __asm__ __volatile__("");
1973 if (wot == 842) return fn(info);
1974 __asm__ __volatile__("");
1975 if (wot == 843) return fn(info);
1976 __asm__ __volatile__("");
1977 if (wot == 844) return fn(info);
1978 __asm__ __volatile__("");
1979 if (wot == 845) return fn(info);
1980 __asm__ __volatile__("");
1981 if (wot == 846) return fn(info);
1982 __asm__ __volatile__("");
1983 if (wot == 847) return fn(info);
1984 __asm__ __volatile__("");
1985 if (wot == 848) return fn(info);
1986 __asm__ __volatile__("");
1987 if (wot == 849) return fn(info);
1988 __asm__ __volatile__("");
1989 if (wot == 850) return fn(info);
1990 __asm__ __volatile__("");
1991 if (wot == 851) return fn(info);
1992 __asm__ __volatile__("");
1993 if (wot == 852) return fn(info);
1994 __asm__ __volatile__("");
1995 if (wot == 853) return fn(info);
1996 __asm__ __volatile__("");
1997 if (wot == 854) return fn(info);
1998 __asm__ __volatile__("");
1999 if (wot == 855) return fn(info);
2000 __asm__ __volatile__("");
2001 if (wot == 856) return fn(info);
2002 __asm__ __volatile__("");
2003 if (wot == 857) return fn(info);
2004 __asm__ __volatile__("");
2005 if (wot == 858) return fn(info);
2006 __asm__ __volatile__("");
2007 if (wot == 859) return fn(info);
2008 __asm__ __volatile__("");
2009 if (wot == 860) return fn(info);
2010 __asm__ __volatile__("");
2011 if (wot == 861) return fn(info);
2012 __asm__ __volatile__("");
2013 if (wot == 862) return fn(info);
2014 __asm__ __volatile__("");
2015 if (wot == 863) return fn(info);
2016 __asm__ __volatile__("");
2017 if (wot == 864) return fn(info);
2018 __asm__ __volatile__("");
2019 if (wot == 865) return fn(info);
2020 __asm__ __volatile__("");
2021 if (wot == 866) return fn(info);
2022 __asm__ __volatile__("");
2023 if (wot == 867) return fn(info);
2024 __asm__ __volatile__("");
2025 if (wot == 868) return fn(info);
2026 __asm__ __volatile__("");
2027 if (wot == 869) return fn(info);
2028 __asm__ __volatile__("");
2029 if (wot == 870) return fn(info);
2030 __asm__ __volatile__("");
2031 if (wot == 871) return fn(info);
2032 __asm__ __volatile__("");
2033 if (wot == 872) return fn(info);
2034 __asm__ __volatile__("");
2035 if (wot == 873) return fn(info);
2036 __asm__ __volatile__("");
2037 if (wot == 874) return fn(info);
2038 __asm__ __volatile__("");
2039 if (wot == 875) return fn(info);
2040 __asm__ __volatile__("");
2041 if (wot == 876) return fn(info);
2042 __asm__ __volatile__("");
2043 if (wot == 877) return fn(info);
2044 __asm__ __volatile__("");
2045 if (wot == 878) return fn(info);
2046 __asm__ __volatile__("");
2047 if (wot == 879) return fn(info);
2048 __asm__ __volatile__("");
2049 if (wot == 880) return fn(info);
2050 __asm__ __volatile__("");
2051 if (wot == 881) return fn(info);
2052 __asm__ __volatile__("");
2053 if (wot == 882) return fn(info);
2054 __asm__ __volatile__("");
2055 if (wot == 883) return fn(info);
2056 __asm__ __volatile__("");
2057 if (wot == 884) return fn(info);
2058 __asm__ __volatile__("");
2059 if (wot == 885) return fn(info);
2060 __asm__ __volatile__("");
2061 if (wot == 886) return fn(info);
2062 __asm__ __volatile__("");
2063 if (wot == 887) return fn(info);
2064 __asm__ __volatile__("");
2065 if (wot == 888) return fn(info);
2066 __asm__ __volatile__("");
2067 if (wot == 889) return fn(info);
2068 __asm__ __volatile__("");
2069 if (wot == 890) return fn(info);
2070 __asm__ __volatile__("");
2071 if (wot == 891) return fn(info);
2072 __asm__ __volatile__("");
2073 if (wot == 892) return fn(info);
2074 __asm__ __volatile__("");
2075 if (wot == 893) return fn(info);
2076 __asm__ __volatile__("");
2077 if (wot == 894) return fn(info);
2078 __asm__ __volatile__("");
2079 if (wot == 895) return fn(info);
2080 __asm__ __volatile__("");
2081 if (wot == 896) return fn(info);
2082 __asm__ __volatile__("");
2083 if (wot == 897) return fn(info);
2084 __asm__ __volatile__("");
2085 if (wot == 898) return fn(info);
2086 __asm__ __volatile__("");
2087 if (wot == 899) return fn(info);
2088 __asm__ __volatile__("");
2089 if (wot == 900) return fn(info);
2090 __asm__ __volatile__("");
2091 if (wot == 901) return fn(info);
2092 __asm__ __volatile__("");
2093 if (wot == 902) return fn(info);
2094 __asm__ __volatile__("");
2095 if (wot == 903) return fn(info);
2096 __asm__ __volatile__("");
2097 if (wot == 904) return fn(info);
2098 __asm__ __volatile__("");
2099 if (wot == 905) return fn(info);
2100 __asm__ __volatile__("");
2101 if (wot == 906) return fn(info);
2102 __asm__ __volatile__("");
2103 if (wot == 907) return fn(info);
2104 __asm__ __volatile__("");
2105 if (wot == 908) return fn(info);
2106 __asm__ __volatile__("");
2107 if (wot == 909) return fn(info);
2108 __asm__ __volatile__("");
2109 if (wot == 910) return fn(info);
2110 __asm__ __volatile__("");
2111 if (wot == 911) return fn(info);
2112 __asm__ __volatile__("");
2113 if (wot == 912) return fn(info);
2114 __asm__ __volatile__("");
2115 if (wot == 913) return fn(info);
2116 __asm__ __volatile__("");
2117 if (wot == 914) return fn(info);
2118 __asm__ __volatile__("");
2119 if (wot == 915) return fn(info);
2120 __asm__ __volatile__("");
2121 if (wot == 916) return fn(info);
2122 __asm__ __volatile__("");
2123 if (wot == 917) return fn(info);
2124 __asm__ __volatile__("");
2125 if (wot == 918) return fn(info);
2126 __asm__ __volatile__("");
2127 if (wot == 919) return fn(info);
2128 __asm__ __volatile__("");
2129 if (wot == 920) return fn(info);
2130 __asm__ __volatile__("");
2131 if (wot == 921) return fn(info);
2132 __asm__ __volatile__("");
2133 if (wot == 922) return fn(info);
2134 __asm__ __volatile__("");
2135 if (wot == 923) return fn(info);
2136 __asm__ __volatile__("");
2137 if (wot == 924) return fn(info);
2138 __asm__ __volatile__("");
2139 if (wot == 925) return fn(info);
2140 __asm__ __volatile__("");
2141 if (wot == 926) return fn(info);
2142 __asm__ __volatile__("");
2143 if (wot == 927) return fn(info);
2144 __asm__ __volatile__("");
2145 if (wot == 928) return fn(info);
2146 __asm__ __volatile__("");
2147 if (wot == 929) return fn(info);
2148 __asm__ __volatile__("");
2149 if (wot == 930) return fn(info);
2150 __asm__ __volatile__("");
2151 if (wot == 931) return fn(info);
2152 __asm__ __volatile__("");
2153 if (wot == 932) return fn(info);
2154 __asm__ __volatile__("");
2155 if (wot == 933) return fn(info);
2156 __asm__ __volatile__("");
2157 if (wot == 934) return fn(info);
2158 __asm__ __volatile__("");
2159 if (wot == 935) return fn(info);
2160 __asm__ __volatile__("");
2161 if (wot == 936) return fn(info);
2162 __asm__ __volatile__("");
2163 if (wot == 937) return fn(info);
2164 __asm__ __volatile__("");
2165 if (wot == 938) return fn(info);
2166 __asm__ __volatile__("");
2167 if (wot == 939) return fn(info);
2168 __asm__ __volatile__("");
2169 if (wot == 940) return fn(info);
2170 __asm__ __volatile__("");
2171 if (wot == 941) return fn(info);
2172 __asm__ __volatile__("");
2173 if (wot == 942) return fn(info);
2174 __asm__ __volatile__("");
2175 if (wot == 943) return fn(info);
2176 __asm__ __volatile__("");
2177 if (wot == 944) return fn(info);
2178 __asm__ __volatile__("");
2179 if (wot == 945) return fn(info);
2180 __asm__ __volatile__("");
2181 if (wot == 946) return fn(info);
2182 __asm__ __volatile__("");
2183 if (wot == 947) return fn(info);
2184 __asm__ __volatile__("");
2185 if (wot == 948) return fn(info);
2186 __asm__ __volatile__("");
2187 if (wot == 949) return fn(info);
2188 __asm__ __volatile__("");
2189 if (wot == 950) return fn(info);
2190 __asm__ __volatile__("");
2191 if (wot == 951) return fn(info);
2192 __asm__ __volatile__("");
2193 if (wot == 952) return fn(info);
2194 __asm__ __volatile__("");
2195 if (wot == 953) return fn(info);
2196 __asm__ __volatile__("");
2197 if (wot == 954) return fn(info);
2198 __asm__ __volatile__("");
2199 if (wot == 955) return fn(info);
2200 __asm__ __volatile__("");
2201 if (wot == 956) return fn(info);
2202 __asm__ __volatile__("");
2203 if (wot == 957) return fn(info);
2204 __asm__ __volatile__("");
2205 if (wot == 958) return fn(info);
2206 __asm__ __volatile__("");
2207 if (wot == 959) return fn(info);
2208 __asm__ __volatile__("");
2209 if (wot == 960) return fn(info);
2210 __asm__ __volatile__("");
2211 if (wot == 961) return fn(info);
2212 __asm__ __volatile__("");
2213 if (wot == 962) return fn(info);
2214 __asm__ __volatile__("");
2215 if (wot == 963) return fn(info);
2216 __asm__ __volatile__("");
2217 if (wot == 964) return fn(info);
2218 __asm__ __volatile__("");
2219 if (wot == 965) return fn(info);
2220 __asm__ __volatile__("");
2221 if (wot == 966) return fn(info);
2222 __asm__ __volatile__("");
2223 if (wot == 967) return fn(info);
2224 __asm__ __volatile__("");
2225 if (wot == 968) return fn(info);
2226 __asm__ __volatile__("");
2227 if (wot == 969) return fn(info);
2228 __asm__ __volatile__("");
2229 if (wot == 970) return fn(info);
2230 __asm__ __volatile__("");
2231 if (wot == 971) return fn(info);
2232 __asm__ __volatile__("");
2233 if (wot == 972) return fn(info);
2234 __asm__ __volatile__("");
2235 if (wot == 973) return fn(info);
2236 __asm__ __volatile__("");
2237 if (wot == 974) return fn(info);
2238 __asm__ __volatile__("");
2239 if (wot == 975) return fn(info);
2240 __asm__ __volatile__("");
2241 if (wot == 976) return fn(info);
2242 __asm__ __volatile__("");
2243 if (wot == 977) return fn(info);
2244 __asm__ __volatile__("");
2245 if (wot == 978) return fn(info);
2246 __asm__ __volatile__("");
2247 if (wot == 979) return fn(info);
2248 __asm__ __volatile__("");
2249 if (wot == 980) return fn(info);
2250 __asm__ __volatile__("");
2251 if (wot == 981) return fn(info);
2252 __asm__ __volatile__("");
2253 if (wot == 982) return fn(info);
2254 __asm__ __volatile__("");
2255 if (wot == 983) return fn(info);
2256 __asm__ __volatile__("");
2257 if (wot == 984) return fn(info);
2258 __asm__ __volatile__("");
2259 if (wot == 985) return fn(info);
2260 __asm__ __volatile__("");
2261 if (wot == 986) return fn(info);
2262 __asm__ __volatile__("");
2263 if (wot == 987) return fn(info);
2264 __asm__ __volatile__("");
2265 if (wot == 988) return fn(info);
2266 __asm__ __volatile__("");
2267 if (wot == 989) return fn(info);
2268 __asm__ __volatile__("");
2269 if (wot == 990) return fn(info);
2270 __asm__ __volatile__("");
2271 if (wot == 991) return fn(info);
2272 __asm__ __volatile__("");
2273 if (wot == 992) return fn(info);
2274 __asm__ __volatile__("");
2275 if (wot == 993) return fn(info);
2276 __asm__ __volatile__("");
2277 if (wot == 994) return fn(info);
2278 __asm__ __volatile__("");
2279 if (wot == 995) return fn(info);
2280 __asm__ __volatile__("");
2281 if (wot == 996) return fn(info);
2282 __asm__ __volatile__("");
2283 if (wot == 997) return fn(info);
2284 __asm__ __volatile__("");
2285 if (wot == 998) return fn(info);
2286 __asm__ __volatile__("");
2287 if (wot == 999) return fn(info);
2288 __asm__ __volatile__("");
2289 assert(0);
2290 /*NOTREACHED*/return 0;
2291 }
2292