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