l4/pkg/valgrind/src/valgrind-3.6.0-svn/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    { 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
  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
  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
  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
 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 }