← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to helgrind/tests/tc19_shadowmem.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrés Roldán
  • Date: 2008-06-13 02:31:40 UTC
  • mto: (1.4.1 upstream) (2.2.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20080613023140-iwk33rz9rhvfkr96
Import upstream version 3.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
helgrind/tests/tc19_shadowmem.c
 
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
 
 
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
   for (i = firstoff; i <= lastoff; i += 1) {
 
33
      char* ptr = (char*)&arr[i];
 
34
      if (i == skipoff) {
 
35
        *ptr = 0;
 
36
      } else {
 
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
 
 
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
   for (i = firstoff; i <= lastoff; i += 2) {
 
57
      short* ptr = (short*)&arr[i];
 
58
      if (i == skipoff) {
 
59
        *ptr = 0;
 
60
      } else {
 
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
 
 
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
   for (i = firstoff; i <= lastoff; i += 4) {
 
81
      int* ptr = (int*)&arr[i];
 
82
      if (i == skipoff) {
 
83
        *ptr = 0;
 
84
      } else {
 
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
 
 
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
   for (i = firstoff; i <= lastoff; i += 8) {
 
105
      double* ptr = (double*)&arr[i];
 
106
      if (i == skipoff) {
 
107
        *ptr = 0;
 
108
      } else {
 
109
        r= pthread_mutex_lock( &mx ); assert(!r);
 
110
        *ptr = 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
 
 
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
 
 
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
   return 0; /* keep gcc happy on AIX */
 
2291
}