javascripts/vm.js

   1 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
   2 // Note: Some Emscripten settings may limit the speed of the generated code.
   3 // TODO: " u s e   s t r i c t ";
   4
   5 try {
   6   this['Module'] = Module;
   7 } catch(e) {
   8   this['Module'] = Module = {};
   9 }
  10
  11 // The environment setup code below is customized to use Module.
  12 // *** Environment setup code ***
  13 var ENVIRONMENT_IS_NODE = typeof process === 'object';
  14 var ENVIRONMENT_IS_WEB = typeof window === 'object';
  15 var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
  16 var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
  17
  18 if (ENVIRONMENT_IS_NODE) {
  19   // Expose functionality in the same simple way that the shells work
  20   // Note that we pollute the global namespace here, otherwise we break in node
  21   Module['print'] = function(x) {
  22     process['stdout'].write(x + '\n');
  23   };
  24   Module['printErr'] = function(x) {
  25     process['stderr'].write(x + '\n');
  26   };
  27
  28   var nodeFS = require('fs');
  29   var nodePath = require('path');
  30
  31   Module['read'] = function(filename) {
  32     filename = nodePath['normalize'](filename);
  33     var ret = nodeFS['readFileSync'](filename).toString();
  34     // The path is absolute if the normalized version is the same as the resolved.
  35     if (!ret && filename != nodePath['resolve'](filename)) {
  36       filename = path.join(__dirname, '..', 'src', filename);
  37       ret = nodeFS['readFileSync'](filename).toString();
  38     }
  39     return ret;
  40   };
  41
  42   Module['load'] = function(f) {
  43     globalEval(read(f));
  44   };
  45
  46   if (!Module['arguments']) {
  47     Module['arguments'] = process['argv'].slice(2);
  48   }
  49 }
  50
  51 if (ENVIRONMENT_IS_SHELL) {
  52   Module['print'] = print;
  53   if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
  54
  55   // Polyfill over SpiderMonkey/V8 differences
  56   if (typeof read != 'undefined') {
  57     Module['read'] = read;
  58   } else {
  59     Module['read'] = function(f) { snarf(f) };
  60   }
  61
  62   if (!Module['arguments']) {
  63     if (typeof scriptArgs != 'undefined') {
  64       Module['arguments'] = scriptArgs;
  65     } else if (typeof arguments != 'undefined') {
  66       Module['arguments'] = arguments;
  67     }
  68   }
  69 }
  70
  71 if (ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER) {
  72   if (!Module['print']) {
  73     Module['print'] = function(x) {
  74       console.log(x);
  75     };
  76   }
  77
  78   if (!Module['printErr']) {
  79     Module['printErr'] = function(x) {
  80       console.log(x);
  81     };
  82   }
  83 }
  84
  85 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  86   Module['read'] = function(url) {
  87     var xhr = new XMLHttpRequest();
  88     xhr.open('GET', url, false);
  89     xhr.send(null);
  90     return xhr.responseText;
  91   };
  92
  93   if (!Module['arguments']) {
  94     if (typeof arguments != 'undefined') {
  95       Module['arguments'] = arguments;
  96     }
  97   }
  98 }
  99
 100 if (ENVIRONMENT_IS_WORKER) {
 101   // We can do very little here...
 102   var TRY_USE_DUMP = false;
 103   if (!Module['print']) {
 104     Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
 105       dump(x);
 106     }) : (function(x) {
 107       // self.postMessage(x); // enable this if you want stdout to be sent as messages
 108     }));
 109   }
 110
 111   Module['load'] = importScripts;
 112 }
 113
 114 if (!ENVIRONMENT_IS_WORKER && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL) {
 115   // Unreachable because SHELL is dependant on the others
 116   throw 'Unknown runtime environment. Where are we?';
 117 }
 118
 119 function globalEval(x) {
 120   eval.call(null, x);
 121 }
 122 if (!Module['load'] == 'undefined' && Module['read']) {
 123   Module['load'] = function(f) {
 124     globalEval(Module['read'](f));
 125   };
 126 }
 127 if (!Module['print']) {
 128   Module['print'] = function(){};
 129 }
 130 if (!Module['printErr']) {
 131   Module['printErr'] = Module['print'];
 132 }
 133 if (!Module['arguments']) {
 134   Module['arguments'] = [];
 135 }
 136 // *** Environment setup code ***
 137
 138 // Closure helpers
 139 Module.print = Module['print'];
 140 Module.printErr = Module['printErr'];
 141
 142 // Callbacks
 143 if (!Module['preRun']) Module['preRun'] = [];
 144 if (!Module['postRun']) Module['postRun'] = [];
 145
 146
 147 // === Auto-generated preamble library stuff ===
 148
 149 //========================================
 150 // Runtime code shared with compiler
 151 //========================================
 152
 153 var Runtime = {
 154   stackSave: function () {
 155     return STACKTOP;
 156   },
 157   stackRestore: function (stackTop) {
 158     STACKTOP = stackTop;
 159   },
 160   forceAlign: function (target, quantum) {
 161     quantum = quantum || 4;
 162     if (quantum == 1) return target;
 163     if (isNumber(target) && isNumber(quantum)) {
 164       return Math.ceil(target/quantum)*quantum;
 165     } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
 166       var logg = log2(quantum);
 167       return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')';
 168     }
 169     return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
 170   },
 171   isNumberType: function (type) {
 172     return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
 173   },
 174   isPointerType: function isPointerType(type) {
 175   return type[type.length-1] == '*';
 176 },
 177   isStructType: function isStructType(type) {
 178   if (isPointerType(type)) return false;
 179   if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs
 180   if (/<?{ ?[^}]* ?}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
 181   // See comment in isStructPointerType()
 182   return type[0] == '%';
 183 },
 184   INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
 185   FLOAT_TYPES: {"float":0,"double":0},
 186   bitshift64: function (low, high, op, bits) {
 187     var ander = Math.pow(2, bits)-1;
 188     if (bits < 32) {
 189       switch (op) {
 190         case 'shl':
 191           return [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))];
 192         case 'ashr':
 193           return [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0];
 194         case 'lshr':
 195           return [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits];
 196       }
 197     } else if (bits == 32) {
 198       switch (op) {
 199         case 'shl':
 200           return [0, low];
 201         case 'ashr':
 202           return [high, (high|0) < 0 ? ander : 0];
 203         case 'lshr':
 204           return [high, 0];
 205       }
 206     } else { // bits > 32
 207       switch (op) {
 208         case 'shl':
 209           return [0, low << (bits - 32)];
 210         case 'ashr':
 211           return [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0];
 212         case 'lshr':
 213           return [high >>>  (bits - 32) , 0];
 214       }
 215     }
 216     abort('unknown bitshift64 op: ' + [value, op, bits]);
 217   },
 218   or64: function (x, y) {
 219     var l = (x | 0) | (y | 0);
 220     var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
 221     return l + h;
 222   },
 223   and64: function (x, y) {
 224     var l = (x | 0) & (y | 0);
 225     var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
 226     return l + h;
 227   },
 228   xor64: function (x, y) {
 229     var l = (x | 0) ^ (y | 0);
 230     var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
 231     return l + h;
 232   },
 233   getNativeTypeSize: function (type, quantumSize) {
 234     if (Runtime.QUANTUM_SIZE == 1) return 1;
 235     var size = {
 236       '%i1': 1,
 237       '%i8': 1,
 238       '%i16': 2,
 239       '%i32': 4,
 240       '%i64': 8,
 241       "%float": 4,
 242       "%double": 8
 243     }['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc
 244     if (!size) {
 245       if (type.charAt(type.length-1) == '*') {
 246         size = Runtime.QUANTUM_SIZE; // A pointer
 247       } else if (type[0] == 'i') {
 248         var bits = parseInt(type.substr(1));
 249         assert(bits % 8 == 0);
 250         size = bits/8;
 251       }
 252     }
 253     return size;
 254   },
 255   getNativeFieldSize: function (type) {
 256     return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
 257   },
 258   dedup: function dedup(items, ident) {
 259   var seen = {};
 260   if (ident) {
 261     return items.filter(function(item) {
 262       if (seen[item[ident]]) return false;
 263       seen[item[ident]] = true;
 264       return true;
 265     });
 266   } else {
 267     return items.filter(function(item) {
 268       if (seen[item]) return false;
 269       seen[item] = true;
 270       return true;
 271     });
 272   }
 273 },
 274   set: function set() {
 275   var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
 276   var ret = {};
 277   for (var i = 0; i < args.length; i++) {
 278     ret[args[i]] = 0;
 279   }
 280   return ret;
 281 },
 282   calculateStructAlignment: function calculateStructAlignment(type) {
 283     type.flatSize = 0;
 284     type.alignSize = 0;
 285     var diffs = [];
 286     var prev = -1;
 287     type.flatIndexes = type.fields.map(function(field) {
 288       var size, alignSize;
 289       if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
 290         size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
 291         alignSize = size;
 292       } else if (Runtime.isStructType(field)) {
 293         size = Types.types[field].flatSize;
 294         alignSize = Types.types[field].alignSize;
 295       } else {
 296         throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]);
 297       }
 298       alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE);
 299       type.alignSize = Math.max(type.alignSize, alignSize);
 300       var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
 301       type.flatSize = curr + size;
 302       if (prev >= 0) {
 303         diffs.push(curr-prev);
 304       }
 305       prev = curr;
 306       return curr;
 307     });
 308     type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
 309     if (diffs.length == 0) {
 310       type.flatFactor = type.flatSize;
 311     } else if (Runtime.dedup(diffs).length == 1) {
 312       type.flatFactor = diffs[0];
 313     }
 314     type.needsFlattening = (type.flatFactor != 1);
 315     return type.flatIndexes;
 316   },
 317   generateStructInfo: function (struct, typeName, offset) {
 318     var type, alignment;
 319     if (typeName) {
 320       offset = offset || 0;
 321       type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
 322       if (!type) return null;
 323       if (type.fields.length != struct.length) {
 324         printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
 325         return null;
 326       }
 327       alignment = type.flatIndexes;
 328     } else {
 329       var type = { fields: struct.map(function(item) { return item[0] }) };
 330       alignment = Runtime.calculateStructAlignment(type);
 331     }
 332     var ret = {
 333       __size__: type.flatSize
 334     };
 335     if (typeName) {
 336       struct.forEach(function(item, i) {
 337         if (typeof item === 'string') {
 338           ret[item] = alignment[i] + offset;
 339         } else {
 340           // embedded struct
 341           var key;
 342           for (var k in item) key = k;
 343           ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
 344         }
 345       });
 346     } else {
 347       struct.forEach(function(item, i) {
 348         ret[item[1]] = alignment[i];
 349       });
 350     }
 351     return ret;
 352   },
 353   addFunction: function (func) {
 354     var ret = FUNCTION_TABLE.length;
 355     FUNCTION_TABLE.push(func);
 356     FUNCTION_TABLE.push(0);
 357     return ret;
 358   },
 359   warnOnce: function (text) {
 360     if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
 361     if (!Runtime.warnOnce.shown[text]) {
 362       Runtime.warnOnce.shown[text] = 1;
 363       Module.printErr(text);
 364     }
 365   },
 366   funcWrappers: {},
 367   getFuncWrapper: function (func) {
 368     if (!Runtime.funcWrappers[func]) {
 369       Runtime.funcWrappers[func] = function() {
 370         FUNCTION_TABLE[func].apply(null, arguments);
 371       };
 372     }
 373     return Runtime.funcWrappers[func];
 374   },
 375   UTF8Processor: function () {
 376     var buffer = [];
 377     var needed = 0;
 378     this.processCChar = function (code) {
 379       code = code & 0xff;
 380       if (needed) {
 381         buffer.push(code);
 382         needed--;
 383       }
 384       if (buffer.length == 0) {
 385         if (code < 128) return String.fromCharCode(code);
 386         buffer.push(code);
 387         if (code > 191 && code < 224) {
 388           needed = 1;
 389         } else {
 390           needed = 2;
 391         }
 392         return '';
 393       }
 394       if (needed > 0) return '';
 395       var c1 = buffer[0];
 396       var c2 = buffer[1];
 397       var c3 = buffer[2];
 398       var ret;
 399       if (c1 > 191 && c1 < 224) {
 400         ret = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
 401       } else {
 402         ret = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
 403       }
 404       buffer.length = 0;
 405       return ret;
 406     }
 407     this.processJSString = function(string) {
 408       string = unescape(encodeURIComponent(string));
 409       var ret = [];
 410       for (var i = 0; i < string.length; i++) {
 411         ret.push(string.charCodeAt(i));
 412       }
 413       return ret;
 414     }
 415   },
 416   stackAlloc: function stackAlloc(size) { var ret = STACKTOP;STACKTOP += size;STACKTOP = ((((STACKTOP)+3)>>2)<<2);assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"); return ret; },
 417   staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP += size;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
 418   alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; },
 419   makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; },
 420   QUANTUM_SIZE: 4,
 421   __dummy__: 0
 422 }
 423
 424
 425
 426 var CorrectionsMonitor = {
 427   MAX_ALLOWED: 0, // XXX
 428   corrections: 0,
 429   sigs: {},
 430
 431   note: function(type, succeed, sig) {
 432     if (!succeed) {
 433       this.corrections++;
 434       if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!');
 435     }
 436   },
 437
 438   print: function() {
 439   }
 440 };
 441
 442
 443
 444
 445
 446 //========================================
 447 // Runtime essentials
 448 //========================================
 449
 450 var __THREW__ = false; // Used in checking for thrown exceptions.
 451
 452 var ABORT = false;
 453
 454 var undef = 0;
 455 // tempInt is used for 32-bit signed values or smaller. tempBigInt is used
 456 // for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
 457 var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD;
 458 var tempI64, tempI64b;
 459
 460 function abort(text) {
 461   Module.print(text + ':\n' + (new Error).stack);
 462   ABORT = true;
 463   throw "Assertion: " + text;
 464 }
 465
 466 function assert(condition, text) {
 467   if (!condition) {
 468     abort('Assertion failed: ' + text);
 469   }
 470 }
 471
 472 var globalScope = this;
 473
 474 // C calling interface. A convenient way to call C functions (in C files, or
 475 // defined with extern "C").
 476 //
 477 // Note: LLVM optimizations can inline and remove functions, after which you will not be
 478 //       able to call them. Adding
 479 //
 480 //         __attribute__((used))
 481 //
 482 //       to the function definition will prevent that.
 483 //
 484 // Note: Closure optimizations will minify function names, making
 485 //       functions no longer callable. If you run closure (on by default
 486 //       in -O2 and above), you should export the functions you will call
 487 //       by calling emcc with something like
 488 //
 489 //         -s EXPORTED_FUNCTIONS='["_func1","_func2"]'
 490 //
 491 // @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
 492 // @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
 493 //                   'array' for JavaScript arrays and typed arrays).
 494 // @param argTypes   An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
 495 //                   except that 'array' is not possible (there is no way for us to know the length of the array)
 496 // @param args       An array of the arguments to the function, as native JS values (as in returnType)
 497 //                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
 498 // @return           The return value, as a native JS value (as in returnType)
 499 function ccall(ident, returnType, argTypes, args) {
 500   var stack = 0;
 501   function toC(value, type) {
 502     if (type == 'string') {
 503       if (value === null || value === undefined || value === 0) return 0; // null string
 504       if (!stack) stack = Runtime.stackSave();
 505       var ret = Runtime.stackAlloc(value.length+1);
 506       writeStringToMemory(value, ret);
 507       return ret;
 508     } else if (type == 'array') {
 509       if (!stack) stack = Runtime.stackSave();
 510       var ret = Runtime.stackAlloc(value.length);
 511       writeArrayToMemory(value, ret);
 512       return ret;
 513     }
 514     return value;
 515   }
 516   function fromC(value, type) {
 517     if (type == 'string') {
 518       return Pointer_stringify(value);
 519     }
 520     assert(type != 'array');
 521     return value;
 522   }
 523   try {
 524     var func = eval('_' + ident);
 525   } catch(e) {
 526     try {
 527       func = globalScope['Module']['_' + ident]; // closure exported function
 528     } catch(e) {}
 529   }
 530   assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
 531   var i = 0;
 532   var cArgs = args ? args.map(function(arg) {
 533     return toC(arg, argTypes[i++]);
 534   }) : [];
 535   var ret = fromC(func.apply(null, cArgs), returnType);
 536   if (stack) Runtime.stackRestore(stack);
 537   return ret;
 538 }
 539 Module["ccall"] = ccall;
 540
 541 // Returns a native JS wrapper for a C function. This is similar to ccall, but
 542 // returns a function you can call repeatedly in a normal way. For example:
 543 //
 544 //   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
 545 //   alert(my_function(5, 22));
 546 //   alert(my_function(99, 12));
 547 //
 548 function cwrap(ident, returnType, argTypes) {
 549   // TODO: optimize this, eval the whole function once instead of going through ccall each time
 550   return function() {
 551     return ccall(ident, returnType, argTypes, Array.prototype.slice.call(arguments));
 552   }
 553 }
 554 Module["cwrap"] = cwrap;
 555
 556 // Sets a value in memory in a dynamic way at run-time. Uses the
 557 // type data. This is the same as makeSetValue, except that
 558 // makeSetValue is done at compile-time and generates the needed
 559 // code then, whereas this function picks the right code at
 560 // run-time.
 561 // Note that setValue and getValue only do *aligned* writes and reads!
 562 // Note that ccall uses JS types as for defining types, while setValue and
 563 // getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
 564 function setValue(ptr, value, type, noSafe) {
 565   type = type || 'i8';
 566   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
 567     switch(type) {
 568       case 'i1': HEAP8[(ptr)]=value; break;
 569       case 'i8': HEAP8[(ptr)]=value; break;
 570       case 'i16': HEAP16[((ptr)>>1)]=value; break;
 571       case 'i32': HEAP32[((ptr)>>2)]=value; break;
 572       case 'i64': (tempI64 = [value>>>0,Math.min(Math.floor((value)/4294967296), 4294967295)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
 573       case 'float': HEAPF32[((ptr)>>2)]=value; break;
 574       case 'double': (tempDoubleF64[0]=value,HEAP32[((ptr)>>2)]=tempDoubleI32[0],HEAP32[(((ptr)+(4))>>2)]=tempDoubleI32[1]); break;
 575       default: abort('invalid type for setValue: ' + type);
 576     }
 577 }
 578 Module['setValue'] = setValue;
 579
 580 // Parallel to setValue.
 581 function getValue(ptr, type, noSafe) {
 582   type = type || 'i8';
 583   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
 584     switch(type) {
 585       case 'i1': return HEAP8[(ptr)];
 586       case 'i8': return HEAP8[(ptr)];
 587       case 'i16': return HEAP16[((ptr)>>1)];
 588       case 'i32': return HEAP32[((ptr)>>2)];
 589       case 'i64': return HEAP32[((ptr)>>2)];
 590       case 'float': return HEAPF32[((ptr)>>2)];
 591       case 'double': return (tempDoubleI32[0]=HEAP32[((ptr)>>2)],tempDoubleI32[1]=HEAP32[(((ptr)+(4))>>2)],tempDoubleF64[0]);
 592       default: abort('invalid type for setValue: ' + type);
 593     }
 594   return null;
 595 }
 596 Module['getValue'] = getValue;
 597
 598 var ALLOC_NORMAL = 0; // Tries to use _malloc()
 599 var ALLOC_STACK = 1; // Lives for the duration of the current function call
 600 var ALLOC_STATIC = 2; // Cannot be freed
 601 Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
 602 Module['ALLOC_STACK'] = ALLOC_STACK;
 603 Module['ALLOC_STATIC'] = ALLOC_STATIC;
 604
 605 // allocate(): This is for internal use. You can use it yourself as well, but the interface
 606 //             is a little tricky (see docs right below). The reason is that it is optimized
 607 //             for multiple syntaxes to save space in generated code. So you should
 608 //             normally not use allocate(), and instead allocate memory using _malloc(),
 609 //             initialize it with setValue(), and so forth.
 610 // @slab: An array of data, or a number. If a number, then the size of the block to allocate,
 611 //        in *bytes* (note that this is sometimes confusing: the next parameter does not
 612 //        affect this!)
 613 // @types: Either an array of types, one for each byte (or 0 if no type at that position),
 614 //         or a single type which is used for the entire block. This only matters if there
 615 //         is initial data - if @slab is a number, then this does not matter at all and is
 616 //         ignored.
 617 // @allocator: How to allocate memory, see ALLOC_*
 618 function allocate(slab, types, allocator) {
 619   var zeroinit, size;
 620   if (typeof slab === 'number') {
 621     zeroinit = true;
 622     size = slab;
 623   } else {
 624     zeroinit = false;
 625     size = slab.length;
 626   }
 627
 628   var singleType = typeof types === 'string' ? types : null;
 629
 630   var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
 631
 632   if (zeroinit) {
 633       _memset(ret, 0, size);
 634       return ret;
 635   }
 636
 637   var i = 0, type;
 638   while (i < size) {
 639     var curr = slab[i];
 640
 641     if (typeof curr === 'function') {
 642       curr = Runtime.getFunctionIndex(curr);
 643     }
 644
 645     type = singleType || types[i];
 646     if (type === 0) {
 647       i++;
 648       continue;
 649     }
 650     assert(type, 'Must know what type to store in allocate!');
 651
 652     if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
 653
 654     setValue(ret+i, curr, type);
 655     i += Runtime.getNativeTypeSize(type);
 656   }
 657
 658   return ret;
 659 }
 660 Module['allocate'] = allocate;
 661
 662 function Pointer_stringify(ptr, /* optional */ length) {
 663   var utf8 = new Runtime.UTF8Processor();
 664   var nullTerminated = typeof(length) == "undefined";
 665   var ret = "";
 666   var i = 0;
 667   var t;
 668   while (1) {
 669     t = HEAPU8[((ptr)+(i))];
 670     if (nullTerminated && t == 0) break;
 671     ret += utf8.processCChar(t);
 672     i += 1;
 673     if (!nullTerminated && i == length) break;
 674   }
 675   return ret;
 676 }
 677 Module['Pointer_stringify'] = Pointer_stringify;
 678
 679 function Array_stringify(array) {
 680   var ret = "";
 681   for (var i = 0; i < array.length; i++) {
 682     ret += String.fromCharCode(array[i]);
 683   }
 684   return ret;
 685 }
 686 Module['Array_stringify'] = Array_stringify;
 687
 688 // Memory management
 689
 690 var FUNCTION_TABLE; // XXX: In theory the indexes here can be equal to pointers to stacked or malloced memory. Such comparisons should
 691                     //      be false, but can turn out true. We should probably set the top bit to prevent such issues.
 692
 693 var PAGE_SIZE = 4096;
 694 function alignMemoryPage(x) {
 695   return ((x+4095)>>12)<<12;
 696 }
 697
 698 var HEAP;
 699 var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
 700
 701 var STACK_ROOT, STACKTOP, STACK_MAX;
 702 var STATICTOP;
 703 function enlargeMemory() {
 704   abort('Cannot enlarge memory arrays. Adjust TOTAL_MEMORY (currently ' + TOTAL_MEMORY + ') or compile with ALLOW_MEMORY_GROWTH');
 705 }
 706
 707 var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
 708 var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 10485760;
 709 var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
 710
 711 // Initialize the runtime's memory
 712 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 713   assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
 714          'Cannot fallback to non-typed array case: Code is too specialized');
 715
 716   var buffer = new ArrayBuffer(TOTAL_MEMORY);
 717   HEAP8 = new Int8Array(buffer);
 718   HEAP16 = new Int16Array(buffer);
 719   HEAP32 = new Int32Array(buffer);
 720   HEAPU8 = new Uint8Array(buffer);
 721   HEAPU16 = new Uint16Array(buffer);
 722   HEAPU32 = new Uint32Array(buffer);
 723   HEAPF32 = new Float32Array(buffer);
 724   HEAPF64 = new Float64Array(buffer);
 725
 726   // Endianness check (note: assumes compiler arch was little-endian)
 727   HEAP32[0] = 255;
 728   assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
 729
 730 Module['HEAP'] = HEAP;
 731 Module['HEAP8'] = HEAP8;
 732 Module['HEAP16'] = HEAP16;
 733 Module['HEAP32'] = HEAP32;
 734 Module['HEAPU8'] = HEAPU8;
 735 Module['HEAPU16'] = HEAPU16;
 736 Module['HEAPU32'] = HEAPU32;
 737 Module['HEAPF32'] = HEAPF32;
 738 Module['HEAPF64'] = HEAPF64;
 739
 740 STACK_ROOT = STACKTOP = Runtime.alignMemory(1);
 741 STACK_MAX = STACK_ROOT + TOTAL_STACK;
 742
 743 var tempDoublePtr = Runtime.alignMemory(STACK_MAX, 8);
 744 var tempDoubleI8  = HEAP8.subarray(tempDoublePtr);
 745 var tempDoubleI32 = HEAP32.subarray(tempDoublePtr >> 2);
 746 var tempDoubleF32 = HEAPF32.subarray(tempDoublePtr >> 2);
 747 var tempDoubleF64 = HEAPF64.subarray(tempDoublePtr >> 3);
 748 function copyTempFloat(ptr) { // functions, because inlining this code is increases code size too much
 749   tempDoubleI8[0] = HEAP8[ptr];
 750   tempDoubleI8[1] = HEAP8[ptr+1];
 751   tempDoubleI8[2] = HEAP8[ptr+2];
 752   tempDoubleI8[3] = HEAP8[ptr+3];
 753 }
 754 function copyTempDouble(ptr) {
 755   tempDoubleI8[0] = HEAP8[ptr];
 756   tempDoubleI8[1] = HEAP8[ptr+1];
 757   tempDoubleI8[2] = HEAP8[ptr+2];
 758   tempDoubleI8[3] = HEAP8[ptr+3];
 759   tempDoubleI8[4] = HEAP8[ptr+4];
 760   tempDoubleI8[5] = HEAP8[ptr+5];
 761   tempDoubleI8[6] = HEAP8[ptr+6];
 762   tempDoubleI8[7] = HEAP8[ptr+7];
 763 }
 764 STACK_MAX = tempDoublePtr + 8;
 765
 766 STATICTOP = alignMemoryPage(STACK_MAX);
 767
 768 assert(STATICTOP < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY
 769
 770 var nullString = allocate(intArrayFromString('(null)'), 'i8', ALLOC_STATIC);
 771
 772 function callRuntimeCallbacks(callbacks) {
 773   while(callbacks.length > 0) {
 774     var callback = callbacks.shift();
 775     var func = callback.func;
 776     if (typeof func === 'number') {
 777       func = FUNCTION_TABLE[func];
 778     }
 779     func(callback.arg === undefined ? null : callback.arg);
 780   }
 781 }
 782
 783 var __ATINIT__ = []; // functions called during startup
 784 var __ATMAIN__ = []; // functions called when main() is to be run
 785 var __ATEXIT__ = []; // functions called during shutdown
 786
 787 function initRuntime() {
 788   callRuntimeCallbacks(__ATINIT__);
 789 }
 790 function preMain() {
 791   callRuntimeCallbacks(__ATMAIN__);
 792 }
 793 function exitRuntime() {
 794   callRuntimeCallbacks(__ATEXIT__);
 795
 796   // Print summary of correction activity
 797   CorrectionsMonitor.print();
 798 }
 799
 800 function String_len(ptr) {
 801   var i = ptr;
 802   while (HEAP8[(i++)]) {}; // Note: should be |!= 0|, technically. But this helps catch bugs with undefineds
 803   return i - ptr - 1;
 804 }
 805 Module['String_len'] = String_len;
 806
 807 // Tools
 808
 809 // This processes a JS string into a C-line array of numbers, 0-terminated.
 810 // For LLVM-originating strings, see parser.js:parseLLVMString function
 811 function intArrayFromString(stringy, dontAddNull, length /* optional */) {
 812   var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
 813   if (length) {
 814     ret.length = length;
 815   }
 816   if (!dontAddNull) {
 817     ret.push(0);
 818   }
 819   return ret;
 820 }
 821 Module['intArrayFromString'] = intArrayFromString;
 822
 823 function intArrayToString(array) {
 824   var ret = [];
 825   for (var i = 0; i < array.length; i++) {
 826     var chr = array[i];
 827     if (chr > 0xFF) {
 828         assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ')  at offset ' + i + ' not in 0x00-0xFF.');
 829       chr &= 0xFF;
 830     }
 831     ret.push(String.fromCharCode(chr));
 832   }
 833   return ret.join('');
 834 }
 835 Module['intArrayToString'] = intArrayToString;
 836
 837 // Write a Javascript array to somewhere in the heap
 838 function writeStringToMemory(string, buffer, dontAddNull) {
 839   var array = intArrayFromString(string, dontAddNull);
 840   var i = 0;
 841   while (i < array.length) {
 842     var chr = array[i];
 843     HEAP8[((buffer)+(i))]=chr
 844     i = i + 1;
 845   }
 846 }
 847 Module['writeStringToMemory'] = writeStringToMemory;
 848
 849 function writeArrayToMemory(array, buffer) {
 850   for (var i = 0; i < array.length; i++) {
 851     HEAP8[((buffer)+(i))]=array[i];
 852   }
 853 }
 854 Module['writeArrayToMemory'] = writeArrayToMemory;
 855
 856 var STRING_TABLE = [];
 857
 858 function unSign(value, bits, ignore, sig) {
 859   if (value >= 0) {
 860     return value;
 861   }
 862   return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
 863                     : Math.pow(2, bits)         + value;
 864   // TODO: clean up previous line
 865 }
 866 function reSign(value, bits, ignore, sig) {
 867   if (value <= 0) {
 868     return value;
 869   }
 870   var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
 871                         : Math.pow(2, bits-1);
 872   if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
 873                                                        // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
 874                                                        // TODO: In i64 mode 1, resign the two parts separately and safely
 875     value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
 876   }
 877   return value;
 878 }
 879
 880 // A counter of dependencies for calling run(). If we need to
 881 // do asynchronous work before running, increment this and
 882 // decrement it. Incrementing must happen in a place like
 883 // PRE_RUN_ADDITIONS (used by emcc to add file preloading).
 884 // Note that you can add dependencies in preRun, even though
 885 // it happens right before run - run will be postponed until
 886 // the dependencies are met.
 887 var runDependencies = 0;
 888 var runDependencyTracking = {};
 889 var calledRun = false;
 890 var runDependencyWatcher = null;
 891 function addRunDependency(id) {
 892   runDependencies++;
 893   if (Module['monitorRunDependencies']) {
 894     Module['monitorRunDependencies'](runDependencies);
 895   }
 896   if (id) {
 897     assert(!runDependencyTracking[id]);
 898     runDependencyTracking[id] = 1;
 899     if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
 900       // Check for missing dependencies every few seconds
 901       runDependencyWatcher = setInterval(function() {
 902         var shown = false;
 903         for (var dep in runDependencyTracking) {
 904           if (!shown) {
 905             shown = true;
 906             Module.printErr('still waiting on run dependencies:');
 907           }
 908           Module.printErr('dependency: ' + dep);
 909         }
 910         if (shown) {
 911           Module.printErr('(end of list)');
 912         }
 913       }, 6000);
 914     }
 915   } else {
 916     Module.printErr('warning: run dependency added without ID');
 917   }
 918 }
 919 Module['addRunDependency'] = addRunDependency;
 920 function removeRunDependency(id) {
 921   runDependencies--;
 922   if (Module['monitorRunDependencies']) {
 923     Module['monitorRunDependencies'](runDependencies);
 924   }
 925   if (id) {
 926     assert(runDependencyTracking[id]);
 927     delete runDependencyTracking[id];
 928   } else {
 929     Module.printErr('warning: run dependency removed without ID');
 930   }
 931   if (runDependencies == 0) {
 932     if (runDependencyWatcher !== null) {
 933       clearInterval(runDependencyWatcher);
 934       runDependencyWatcher = null;
 935     }
 936     if (!calledRun) run();
 937   }
 938 }
 939 Module['removeRunDependency'] = removeRunDependency;
 940
 941 Module["preloadedImages"] = {}; // maps url to image data
 942 Module["preloadedAudios"] = {}; // maps url to audio data
 943
 944 // === Body ===
 945
 946
 947
 948
 949 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
 950 // Note: Some Emscripten settings may limit the speed of the generated code.
 951
 952 function _qc_program_code_remove($self, $idx) {
 953   ;
 954   var __label__;
 955   __label__ = 2;
 956   while(1) switch(__label__) {
 957     case 2:
 958       var $1;
 959       var $2;
 960       var $3;
 961       var $i;
 962       var $reall;
 963       $2=$self;
 964       $3=$idx;
 965       var $4=$3;
 966       var $5=$2;
 967       var $6=(($5+8)|0);
 968       var $7=HEAP32[(($6)>>2)];
 969       var $8=(($4)>>>0) >= (($7)>>>0);
 970       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
 971     case 3:
 972       $1=1;
 973       __label__ = 13; break;
 974     case 4:
 975       var $11=$3;
 976       $i=$11;
 977       __label__ = 5; break;
 978     case 5:
 979       var $13=$i;
 980       var $14=$2;
 981       var $15=(($14+8)|0);
 982       var $16=HEAP32[(($15)>>2)];
 983       var $17=((($16)-(1))|0);
 984       var $18=(($13)>>>0) < (($17)>>>0);
 985       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
 986     case 6:
 987       var $20=$i;
 988       var $21=$2;
 989       var $22=(($21+4)|0);
 990       var $23=HEAP32[(($22)>>2)];
 991       var $24=(($23+($20<<3))|0);
 992       var $25=$i;
 993       var $26=((($25)+(1))|0);
 994       var $27=$2;
 995       var $28=(($27+4)|0);
 996       var $29=HEAP32[(($28)>>2)];
 997       var $30=(($29+($26<<3))|0);
 998       var $31=$24;
 999       var $32=$30;
1000       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP16[(($31)>>1)]=HEAP16[(($32)>>1)];HEAP16[((($31)+(2))>>1)]=HEAP16[((($32)+(2))>>1)];HEAP16[((($31)+(4))>>1)]=HEAP16[((($32)+(4))>>1)];HEAP16[((($31)+(6))>>1)]=HEAP16[((($32)+(6))>>1)];
1001       __label__ = 7; break;
1002     case 7:
1003       var $34=$i;
1004       var $35=((($34)+(1))|0);
1005       $i=$35;
1006       __label__ = 5; break;
1007     case 8:
1008       var $37=$2;
1009       var $38=(($37+8)|0);
1010       var $39=HEAP32[(($38)>>2)];
1011       var $40=((($39)-(1))|0);
1012       HEAP32[(($38)>>2)]=$40;
1013       var $41=$2;
1014       var $42=(($41+8)|0);
1015       var $43=HEAP32[(($42)>>2)];
1016       var $44=$2;
1017       var $45=(($44+8)|0);
1018       var $46=HEAP32[(($45)>>2)];
1019       var $47=Math.floor(((($46)>>>0))/(2));
1020       var $48=(($43)>>>0) < (($47)>>>0);
1021       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1022     case 9:
1023       var $50=$2;
1024       var $51=(($50+12)|0);
1025       var $52=HEAP32[(($51)>>2)];
1026       var $53=Math.floor(((($52)>>>0))/(2));
1027       HEAP32[(($51)>>2)]=$53;
1028       var $54=$2;
1029       var $55=(($54+8)|0);
1030       var $56=HEAP32[(($55)>>2)];
1031       var $57=((($56<<3))|0);
1032       var $58=_util_memory_a($57, 32, ((STRING_TABLE.__str)|0));
1033       var $59=$58;
1034       $reall=$59;
1035       var $60=$reall;
1036       var $61=(($60)|0)!=0;
1037       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1038     case 10:
1039       $1=0;
1040       __label__ = 13; break;
1041     case 11:
1042       var $64=$reall;
1043       var $65=$64;
1044       var $66=$2;
1045       var $67=(($66+4)|0);
1046       var $68=HEAP32[(($67)>>2)];
1047       var $69=$68;
1048       var $70=$2;
1049       var $71=(($70+8)|0);
1050       var $72=HEAP32[(($71)>>2)];
1051       var $73=((($72<<3))|0);
1052       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 2);
1053       var $74=$2;
1054       var $75=(($74+4)|0);
1055       var $76=HEAP32[(($75)>>2)];
1056       var $77=$76;
1057       _util_memory_d($77, 32, ((STRING_TABLE.__str)|0));
1058       var $78=$reall;
1059       var $79=$2;
1060       var $80=(($79+4)|0);
1061       HEAP32[(($80)>>2)]=$78;
1062       __label__ = 12; break;
1063     case 12:
1064       $1=1;
1065       __label__ = 13; break;
1066     case 13:
1067       var $83=$1;
1068       ;
1069       return $83;
1070     default: assert(0, "bad label: " + __label__);
1071   }
1072 }
1073 _qc_program_code_remove["X"]=1;
1074
1075 function _qc_program_code_add($self, $f) {
1076   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1077   var tempParam = $f; $f = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($f)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($f)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)];
1078   var __label__;
1079   __label__ = 2;
1080   while(1) switch(__label__) {
1081     case 2:
1082       var $1;
1083       var $2;
1084       var $reall;
1085       $2=$self;
1086       var $3=$2;
1087       var $4=(($3+8)|0);
1088       var $5=HEAP32[(($4)>>2)];
1089       var $6=$2;
1090       var $7=(($6+12)|0);
1091       var $8=HEAP32[(($7)>>2)];
1092       var $9=(($5)|0)==(($8)|0);
1093       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1094     case 3:
1095       var $11=$2;
1096       var $12=(($11+12)|0);
1097       var $13=HEAP32[(($12)>>2)];
1098       var $14=(($13)|0)!=0;
1099       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1100     case 4:
1101       var $16=$2;
1102       var $17=(($16+12)|0);
1103       HEAP32[(($17)>>2)]=16;
1104       __label__ = 6; break;
1105     case 5:
1106       var $19=$2;
1107       var $20=(($19+12)|0);
1108       var $21=HEAP32[(($20)>>2)];
1109       var $22=((($21<<1))|0);
1110       HEAP32[(($20)>>2)]=$22;
1111       __label__ = 6; break;
1112     case 6:
1113       var $24=$2;
1114       var $25=(($24+12)|0);
1115       var $26=HEAP32[(($25)>>2)];
1116       var $27=((($26<<3))|0);
1117       var $28=_util_memory_a($27, 32, ((STRING_TABLE.__str)|0));
1118       var $29=$28;
1119       $reall=$29;
1120       var $30=$reall;
1121       var $31=(($30)|0)!=0;
1122       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1123     case 7:
1124       $1=0;
1125       __label__ = 10; break;
1126     case 8:
1127       var $34=$reall;
1128       var $35=$34;
1129       var $36=$2;
1130       var $37=(($36+4)|0);
1131       var $38=HEAP32[(($37)>>2)];
1132       var $39=$38;
1133       var $40=$2;
1134       var $41=(($40+8)|0);
1135       var $42=HEAP32[(($41)>>2)];
1136       var $43=((($42<<3))|0);
1137       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 2);
1138       var $44=$2;
1139       var $45=(($44+4)|0);
1140       var $46=HEAP32[(($45)>>2)];
1141       var $47=$46;
1142       _util_memory_d($47, 32, ((STRING_TABLE.__str)|0));
1143       var $48=$reall;
1144       var $49=$2;
1145       var $50=(($49+4)|0);
1146       HEAP32[(($50)>>2)]=$48;
1147       __label__ = 9; break;
1148     case 9:
1149       var $52=$2;
1150       var $53=(($52+8)|0);
1151       var $54=HEAP32[(($53)>>2)];
1152       var $55=((($54)+(1))|0);
1153       HEAP32[(($53)>>2)]=$55;
1154       var $56=$2;
1155       var $57=(($56+4)|0);
1156       var $58=HEAP32[(($57)>>2)];
1157       var $59=(($58+($54<<3))|0);
1158       var $60=$59;
1159       var $61=$f;
1160       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP16[(($60)>>1)]=HEAP16[(($61)>>1)];HEAP16[((($60)+(2))>>1)]=HEAP16[((($61)+(2))>>1)];HEAP16[((($60)+(4))>>1)]=HEAP16[((($61)+(4))>>1)];HEAP16[((($60)+(6))>>1)]=HEAP16[((($61)+(6))>>1)];
1161       $1=1;
1162       __label__ = 10; break;
1163     case 10:
1164       var $63=$1;
1165       STACKTOP = __stackBase__;
1166       return $63;
1167     default: assert(0, "bad label: " + __label__);
1168   }
1169 }
1170 _qc_program_code_add["X"]=1;
1171
1172 function _qc_program_defs_remove($self, $idx) {
1173   ;
1174   var __label__;
1175   __label__ = 2;
1176   while(1) switch(__label__) {
1177     case 2:
1178       var $1;
1179       var $2;
1180       var $3;
1181       var $i;
1182       var $reall;
1183       $2=$self;
1184       $3=$idx;
1185       var $4=$3;
1186       var $5=$2;
1187       var $6=(($5+20)|0);
1188       var $7=HEAP32[(($6)>>2)];
1189       var $8=(($4)>>>0) >= (($7)>>>0);
1190       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1191     case 3:
1192       $1=1;
1193       __label__ = 13; break;
1194     case 4:
1195       var $11=$3;
1196       $i=$11;
1197       __label__ = 5; break;
1198     case 5:
1199       var $13=$i;
1200       var $14=$2;
1201       var $15=(($14+20)|0);
1202       var $16=HEAP32[(($15)>>2)];
1203       var $17=((($16)-(1))|0);
1204       var $18=(($13)>>>0) < (($17)>>>0);
1205       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1206     case 6:
1207       var $20=$i;
1208       var $21=$2;
1209       var $22=(($21+16)|0);
1210       var $23=HEAP32[(($22)>>2)];
1211       var $24=(($23+($20<<3))|0);
1212       var $25=$i;
1213       var $26=((($25)+(1))|0);
1214       var $27=$2;
1215       var $28=(($27+16)|0);
1216       var $29=HEAP32[(($28)>>2)];
1217       var $30=(($29+($26<<3))|0);
1218       var $31=$24;
1219       var $32=$30;
1220       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($31)>>2)]=HEAP32[(($32)>>2)];HEAP32[((($31)+(4))>>2)]=HEAP32[((($32)+(4))>>2)];
1221       __label__ = 7; break;
1222     case 7:
1223       var $34=$i;
1224       var $35=((($34)+(1))|0);
1225       $i=$35;
1226       __label__ = 5; break;
1227     case 8:
1228       var $37=$2;
1229       var $38=(($37+20)|0);
1230       var $39=HEAP32[(($38)>>2)];
1231       var $40=((($39)-(1))|0);
1232       HEAP32[(($38)>>2)]=$40;
1233       var $41=$2;
1234       var $42=(($41+20)|0);
1235       var $43=HEAP32[(($42)>>2)];
1236       var $44=$2;
1237       var $45=(($44+20)|0);
1238       var $46=HEAP32[(($45)>>2)];
1239       var $47=Math.floor(((($46)>>>0))/(2));
1240       var $48=(($43)>>>0) < (($47)>>>0);
1241       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1242     case 9:
1243       var $50=$2;
1244       var $51=(($50+24)|0);
1245       var $52=HEAP32[(($51)>>2)];
1246       var $53=Math.floor(((($52)>>>0))/(2));
1247       HEAP32[(($51)>>2)]=$53;
1248       var $54=$2;
1249       var $55=(($54+20)|0);
1250       var $56=HEAP32[(($55)>>2)];
1251       var $57=((($56<<3))|0);
1252       var $58=_util_memory_a($57, 33, ((STRING_TABLE.__str)|0));
1253       var $59=$58;
1254       $reall=$59;
1255       var $60=$reall;
1256       var $61=(($60)|0)!=0;
1257       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1258     case 10:
1259       $1=0;
1260       __label__ = 13; break;
1261     case 11:
1262       var $64=$reall;
1263       var $65=$64;
1264       var $66=$2;
1265       var $67=(($66+16)|0);
1266       var $68=HEAP32[(($67)>>2)];
1267       var $69=$68;
1268       var $70=$2;
1269       var $71=(($70+20)|0);
1270       var $72=HEAP32[(($71)>>2)];
1271       var $73=((($72<<3))|0);
1272       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1273       var $74=$2;
1274       var $75=(($74+16)|0);
1275       var $76=HEAP32[(($75)>>2)];
1276       var $77=$76;
1277       _util_memory_d($77, 33, ((STRING_TABLE.__str)|0));
1278       var $78=$reall;
1279       var $79=$2;
1280       var $80=(($79+16)|0);
1281       HEAP32[(($80)>>2)]=$78;
1282       __label__ = 12; break;
1283     case 12:
1284       $1=1;
1285       __label__ = 13; break;
1286     case 13:
1287       var $83=$1;
1288       ;
1289       return $83;
1290     default: assert(0, "bad label: " + __label__);
1291   }
1292 }
1293 _qc_program_defs_remove["X"]=1;
1294
1295 function _qc_program_defs_add($self, $f) {
1296   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1297   var tempParam = $f; $f = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($f)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($f)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)];
1298   var __label__;
1299   __label__ = 2;
1300   while(1) switch(__label__) {
1301     case 2:
1302       var $1;
1303       var $2;
1304       var $reall;
1305       $2=$self;
1306       var $3=$2;
1307       var $4=(($3+20)|0);
1308       var $5=HEAP32[(($4)>>2)];
1309       var $6=$2;
1310       var $7=(($6+24)|0);
1311       var $8=HEAP32[(($7)>>2)];
1312       var $9=(($5)|0)==(($8)|0);
1313       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1314     case 3:
1315       var $11=$2;
1316       var $12=(($11+24)|0);
1317       var $13=HEAP32[(($12)>>2)];
1318       var $14=(($13)|0)!=0;
1319       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1320     case 4:
1321       var $16=$2;
1322       var $17=(($16+24)|0);
1323       HEAP32[(($17)>>2)]=16;
1324       __label__ = 6; break;
1325     case 5:
1326       var $19=$2;
1327       var $20=(($19+24)|0);
1328       var $21=HEAP32[(($20)>>2)];
1329       var $22=((($21<<1))|0);
1330       HEAP32[(($20)>>2)]=$22;
1331       __label__ = 6; break;
1332     case 6:
1333       var $24=$2;
1334       var $25=(($24+24)|0);
1335       var $26=HEAP32[(($25)>>2)];
1336       var $27=((($26<<3))|0);
1337       var $28=_util_memory_a($27, 33, ((STRING_TABLE.__str)|0));
1338       var $29=$28;
1339       $reall=$29;
1340       var $30=$reall;
1341       var $31=(($30)|0)!=0;
1342       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1343     case 7:
1344       $1=0;
1345       __label__ = 10; break;
1346     case 8:
1347       var $34=$reall;
1348       var $35=$34;
1349       var $36=$2;
1350       var $37=(($36+16)|0);
1351       var $38=HEAP32[(($37)>>2)];
1352       var $39=$38;
1353       var $40=$2;
1354       var $41=(($40+20)|0);
1355       var $42=HEAP32[(($41)>>2)];
1356       var $43=((($42<<3))|0);
1357       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1358       var $44=$2;
1359       var $45=(($44+16)|0);
1360       var $46=HEAP32[(($45)>>2)];
1361       var $47=$46;
1362       _util_memory_d($47, 33, ((STRING_TABLE.__str)|0));
1363       var $48=$reall;
1364       var $49=$2;
1365       var $50=(($49+16)|0);
1366       HEAP32[(($50)>>2)]=$48;
1367       __label__ = 9; break;
1368     case 9:
1369       var $52=$2;
1370       var $53=(($52+20)|0);
1371       var $54=HEAP32[(($53)>>2)];
1372       var $55=((($54)+(1))|0);
1373       HEAP32[(($53)>>2)]=$55;
1374       var $56=$2;
1375       var $57=(($56+16)|0);
1376       var $58=HEAP32[(($57)>>2)];
1377       var $59=(($58+($54<<3))|0);
1378       var $60=$59;
1379       var $61=$f;
1380       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($60)>>2)]=HEAP32[(($61)>>2)];HEAP32[((($60)+(4))>>2)]=HEAP32[((($61)+(4))>>2)];
1381       $1=1;
1382       __label__ = 10; break;
1383     case 10:
1384       var $63=$1;
1385       STACKTOP = __stackBase__;
1386       return $63;
1387     default: assert(0, "bad label: " + __label__);
1388   }
1389 }
1390 _qc_program_defs_add["X"]=1;
1391
1392 function _qc_program_fields_remove($self, $idx) {
1393   ;
1394   var __label__;
1395   __label__ = 2;
1396   while(1) switch(__label__) {
1397     case 2:
1398       var $1;
1399       var $2;
1400       var $3;
1401       var $i;
1402       var $reall;
1403       $2=$self;
1404       $3=$idx;
1405       var $4=$3;
1406       var $5=$2;
1407       var $6=(($5+32)|0);
1408       var $7=HEAP32[(($6)>>2)];
1409       var $8=(($4)>>>0) >= (($7)>>>0);
1410       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1411     case 3:
1412       $1=1;
1413       __label__ = 13; break;
1414     case 4:
1415       var $11=$3;
1416       $i=$11;
1417       __label__ = 5; break;
1418     case 5:
1419       var $13=$i;
1420       var $14=$2;
1421       var $15=(($14+32)|0);
1422       var $16=HEAP32[(($15)>>2)];
1423       var $17=((($16)-(1))|0);
1424       var $18=(($13)>>>0) < (($17)>>>0);
1425       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1426     case 6:
1427       var $20=$i;
1428       var $21=$2;
1429       var $22=(($21+28)|0);
1430       var $23=HEAP32[(($22)>>2)];
1431       var $24=(($23+($20<<3))|0);
1432       var $25=$i;
1433       var $26=((($25)+(1))|0);
1434       var $27=$2;
1435       var $28=(($27+28)|0);
1436       var $29=HEAP32[(($28)>>2)];
1437       var $30=(($29+($26<<3))|0);
1438       var $31=$24;
1439       var $32=$30;
1440       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($31)>>2)]=HEAP32[(($32)>>2)];HEAP32[((($31)+(4))>>2)]=HEAP32[((($32)+(4))>>2)];
1441       __label__ = 7; break;
1442     case 7:
1443       var $34=$i;
1444       var $35=((($34)+(1))|0);
1445       $i=$35;
1446       __label__ = 5; break;
1447     case 8:
1448       var $37=$2;
1449       var $38=(($37+32)|0);
1450       var $39=HEAP32[(($38)>>2)];
1451       var $40=((($39)-(1))|0);
1452       HEAP32[(($38)>>2)]=$40;
1453       var $41=$2;
1454       var $42=(($41+32)|0);
1455       var $43=HEAP32[(($42)>>2)];
1456       var $44=$2;
1457       var $45=(($44+32)|0);
1458       var $46=HEAP32[(($45)>>2)];
1459       var $47=Math.floor(((($46)>>>0))/(2));
1460       var $48=(($43)>>>0) < (($47)>>>0);
1461       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1462     case 9:
1463       var $50=$2;
1464       var $51=(($50+36)|0);
1465       var $52=HEAP32[(($51)>>2)];
1466       var $53=Math.floor(((($52)>>>0))/(2));
1467       HEAP32[(($51)>>2)]=$53;
1468       var $54=$2;
1469       var $55=(($54+32)|0);
1470       var $56=HEAP32[(($55)>>2)];
1471       var $57=((($56<<3))|0);
1472       var $58=_util_memory_a($57, 34, ((STRING_TABLE.__str)|0));
1473       var $59=$58;
1474       $reall=$59;
1475       var $60=$reall;
1476       var $61=(($60)|0)!=0;
1477       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1478     case 10:
1479       $1=0;
1480       __label__ = 13; break;
1481     case 11:
1482       var $64=$reall;
1483       var $65=$64;
1484       var $66=$2;
1485       var $67=(($66+28)|0);
1486       var $68=HEAP32[(($67)>>2)];
1487       var $69=$68;
1488       var $70=$2;
1489       var $71=(($70+32)|0);
1490       var $72=HEAP32[(($71)>>2)];
1491       var $73=((($72<<3))|0);
1492       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1493       var $74=$2;
1494       var $75=(($74+28)|0);
1495       var $76=HEAP32[(($75)>>2)];
1496       var $77=$76;
1497       _util_memory_d($77, 34, ((STRING_TABLE.__str)|0));
1498       var $78=$reall;
1499       var $79=$2;
1500       var $80=(($79+28)|0);
1501       HEAP32[(($80)>>2)]=$78;
1502       __label__ = 12; break;
1503     case 12:
1504       $1=1;
1505       __label__ = 13; break;
1506     case 13:
1507       var $83=$1;
1508       ;
1509       return $83;
1510     default: assert(0, "bad label: " + __label__);
1511   }
1512 }
1513 _qc_program_fields_remove["X"]=1;
1514
1515 function _qc_program_fields_add($self, $f) {
1516   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1517   var tempParam = $f; $f = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($f)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($f)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)];
1518   var __label__;
1519   __label__ = 2;
1520   while(1) switch(__label__) {
1521     case 2:
1522       var $1;
1523       var $2;
1524       var $reall;
1525       $2=$self;
1526       var $3=$2;
1527       var $4=(($3+32)|0);
1528       var $5=HEAP32[(($4)>>2)];
1529       var $6=$2;
1530       var $7=(($6+36)|0);
1531       var $8=HEAP32[(($7)>>2)];
1532       var $9=(($5)|0)==(($8)|0);
1533       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1534     case 3:
1535       var $11=$2;
1536       var $12=(($11+36)|0);
1537       var $13=HEAP32[(($12)>>2)];
1538       var $14=(($13)|0)!=0;
1539       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1540     case 4:
1541       var $16=$2;
1542       var $17=(($16+36)|0);
1543       HEAP32[(($17)>>2)]=16;
1544       __label__ = 6; break;
1545     case 5:
1546       var $19=$2;
1547       var $20=(($19+36)|0);
1548       var $21=HEAP32[(($20)>>2)];
1549       var $22=((($21<<1))|0);
1550       HEAP32[(($20)>>2)]=$22;
1551       __label__ = 6; break;
1552     case 6:
1553       var $24=$2;
1554       var $25=(($24+36)|0);
1555       var $26=HEAP32[(($25)>>2)];
1556       var $27=((($26<<3))|0);
1557       var $28=_util_memory_a($27, 34, ((STRING_TABLE.__str)|0));
1558       var $29=$28;
1559       $reall=$29;
1560       var $30=$reall;
1561       var $31=(($30)|0)!=0;
1562       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1563     case 7:
1564       $1=0;
1565       __label__ = 10; break;
1566     case 8:
1567       var $34=$reall;
1568       var $35=$34;
1569       var $36=$2;
1570       var $37=(($36+28)|0);
1571       var $38=HEAP32[(($37)>>2)];
1572       var $39=$38;
1573       var $40=$2;
1574       var $41=(($40+32)|0);
1575       var $42=HEAP32[(($41)>>2)];
1576       var $43=((($42<<3))|0);
1577       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1578       var $44=$2;
1579       var $45=(($44+28)|0);
1580       var $46=HEAP32[(($45)>>2)];
1581       var $47=$46;
1582       _util_memory_d($47, 34, ((STRING_TABLE.__str)|0));
1583       var $48=$reall;
1584       var $49=$2;
1585       var $50=(($49+28)|0);
1586       HEAP32[(($50)>>2)]=$48;
1587       __label__ = 9; break;
1588     case 9:
1589       var $52=$2;
1590       var $53=(($52+32)|0);
1591       var $54=HEAP32[(($53)>>2)];
1592       var $55=((($54)+(1))|0);
1593       HEAP32[(($53)>>2)]=$55;
1594       var $56=$2;
1595       var $57=(($56+28)|0);
1596       var $58=HEAP32[(($57)>>2)];
1597       var $59=(($58+($54<<3))|0);
1598       var $60=$59;
1599       var $61=$f;
1600       assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($60)>>2)]=HEAP32[(($61)>>2)];HEAP32[((($60)+(4))>>2)]=HEAP32[((($61)+(4))>>2)];
1601       $1=1;
1602       __label__ = 10; break;
1603     case 10:
1604       var $63=$1;
1605       STACKTOP = __stackBase__;
1606       return $63;
1607     default: assert(0, "bad label: " + __label__);
1608   }
1609 }
1610 _qc_program_fields_add["X"]=1;
1611
1612 function _qc_program_functions_remove($self, $idx) {
1613   ;
1614   var __label__;
1615   __label__ = 2;
1616   while(1) switch(__label__) {
1617     case 2:
1618       var $1;
1619       var $2;
1620       var $3;
1621       var $i;
1622       var $reall;
1623       $2=$self;
1624       $3=$idx;
1625       var $4=$3;
1626       var $5=$2;
1627       var $6=(($5+44)|0);
1628       var $7=HEAP32[(($6)>>2)];
1629       var $8=(($4)>>>0) >= (($7)>>>0);
1630       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1631     case 3:
1632       $1=1;
1633       __label__ = 13; break;
1634     case 4:
1635       var $11=$3;
1636       $i=$11;
1637       __label__ = 5; break;
1638     case 5:
1639       var $13=$i;
1640       var $14=$2;
1641       var $15=(($14+44)|0);
1642       var $16=HEAP32[(($15)>>2)];
1643       var $17=((($16)-(1))|0);
1644       var $18=(($13)>>>0) < (($17)>>>0);
1645       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1646     case 6:
1647       var $20=$i;
1648       var $21=$2;
1649       var $22=(($21+40)|0);
1650       var $23=HEAP32[(($22)>>2)];
1651       var $24=(($23+($20)*(36))|0);
1652       var $25=$i;
1653       var $26=((($25)+(1))|0);
1654       var $27=$2;
1655       var $28=(($27+40)|0);
1656       var $29=HEAP32[(($28)>>2)];
1657       var $30=(($29+($26)*(36))|0);
1658       var $31=$24;
1659       var $32=$30;
1660       assert(36 % 1 === 0, 'memcpy given ' + 36 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');for (var $$src = $32>>2, $$dest = $31>>2, $$stop = $$src + 9; $$src < $$stop; $$src++, $$dest++) {
1661         HEAP32[$$dest] = HEAP32[$$src]
1662       };
1663       __label__ = 7; break;
1664     case 7:
1665       var $34=$i;
1666       var $35=((($34)+(1))|0);
1667       $i=$35;
1668       __label__ = 5; break;
1669     case 8:
1670       var $37=$2;
1671       var $38=(($37+44)|0);
1672       var $39=HEAP32[(($38)>>2)];
1673       var $40=((($39)-(1))|0);
1674       HEAP32[(($38)>>2)]=$40;
1675       var $41=$2;
1676       var $42=(($41+44)|0);
1677       var $43=HEAP32[(($42)>>2)];
1678       var $44=$2;
1679       var $45=(($44+44)|0);
1680       var $46=HEAP32[(($45)>>2)];
1681       var $47=Math.floor(((($46)>>>0))/(2));
1682       var $48=(($43)>>>0) < (($47)>>>0);
1683       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1684     case 9:
1685       var $50=$2;
1686       var $51=(($50+48)|0);
1687       var $52=HEAP32[(($51)>>2)];
1688       var $53=Math.floor(((($52)>>>0))/(2));
1689       HEAP32[(($51)>>2)]=$53;
1690       var $54=$2;
1691       var $55=(($54+44)|0);
1692       var $56=HEAP32[(($55)>>2)];
1693       var $57=((($56)*(36))|0);
1694       var $58=_util_memory_a($57, 35, ((STRING_TABLE.__str)|0));
1695       var $59=$58;
1696       $reall=$59;
1697       var $60=$reall;
1698       var $61=(($60)|0)!=0;
1699       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1700     case 10:
1701       $1=0;
1702       __label__ = 13; break;
1703     case 11:
1704       var $64=$reall;
1705       var $65=$64;
1706       var $66=$2;
1707       var $67=(($66+40)|0);
1708       var $68=HEAP32[(($67)>>2)];
1709       var $69=$68;
1710       var $70=$2;
1711       var $71=(($70+44)|0);
1712       var $72=HEAP32[(($71)>>2)];
1713       var $73=((($72)*(36))|0);
1714       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1715       var $74=$2;
1716       var $75=(($74+40)|0);
1717       var $76=HEAP32[(($75)>>2)];
1718       var $77=$76;
1719       _util_memory_d($77, 35, ((STRING_TABLE.__str)|0));
1720       var $78=$reall;
1721       var $79=$2;
1722       var $80=(($79+40)|0);
1723       HEAP32[(($80)>>2)]=$78;
1724       __label__ = 12; break;
1725     case 12:
1726       $1=1;
1727       __label__ = 13; break;
1728     case 13:
1729       var $83=$1;
1730       ;
1731       return $83;
1732     default: assert(0, "bad label: " + __label__);
1733   }
1734 }
1735 _qc_program_functions_remove["X"]=1;
1736
1737 function _qc_program_functions_add($self, $f) {
1738   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1739   var tempParam = $f; $f = STACKTOP;STACKTOP += 36;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");for (var $$src = tempParam>>2, $$dest = $f>>2, $$stop = $$src + 9; $$src < $$stop; $$src++, $$dest++) {
1740   HEAP32[$$dest] = HEAP32[$$src]
1741 };
1742   var __label__;
1743   __label__ = 2;
1744   while(1) switch(__label__) {
1745     case 2:
1746       var $1;
1747       var $2;
1748       var $reall;
1749       $2=$self;
1750       var $3=$2;
1751       var $4=(($3+44)|0);
1752       var $5=HEAP32[(($4)>>2)];
1753       var $6=$2;
1754       var $7=(($6+48)|0);
1755       var $8=HEAP32[(($7)>>2)];
1756       var $9=(($5)|0)==(($8)|0);
1757       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1758     case 3:
1759       var $11=$2;
1760       var $12=(($11+48)|0);
1761       var $13=HEAP32[(($12)>>2)];
1762       var $14=(($13)|0)!=0;
1763       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1764     case 4:
1765       var $16=$2;
1766       var $17=(($16+48)|0);
1767       HEAP32[(($17)>>2)]=16;
1768       __label__ = 6; break;
1769     case 5:
1770       var $19=$2;
1771       var $20=(($19+48)|0);
1772       var $21=HEAP32[(($20)>>2)];
1773       var $22=((($21<<1))|0);
1774       HEAP32[(($20)>>2)]=$22;
1775       __label__ = 6; break;
1776     case 6:
1777       var $24=$2;
1778       var $25=(($24+48)|0);
1779       var $26=HEAP32[(($25)>>2)];
1780       var $27=((($26)*(36))|0);
1781       var $28=_util_memory_a($27, 35, ((STRING_TABLE.__str)|0));
1782       var $29=$28;
1783       $reall=$29;
1784       var $30=$reall;
1785       var $31=(($30)|0)!=0;
1786       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1787     case 7:
1788       $1=0;
1789       __label__ = 10; break;
1790     case 8:
1791       var $34=$reall;
1792       var $35=$34;
1793       var $36=$2;
1794       var $37=(($36+40)|0);
1795       var $38=HEAP32[(($37)>>2)];
1796       var $39=$38;
1797       var $40=$2;
1798       var $41=(($40+44)|0);
1799       var $42=HEAP32[(($41)>>2)];
1800       var $43=((($42)*(36))|0);
1801       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1802       var $44=$2;
1803       var $45=(($44+40)|0);
1804       var $46=HEAP32[(($45)>>2)];
1805       var $47=$46;
1806       _util_memory_d($47, 35, ((STRING_TABLE.__str)|0));
1807       var $48=$reall;
1808       var $49=$2;
1809       var $50=(($49+40)|0);
1810       HEAP32[(($50)>>2)]=$48;
1811       __label__ = 9; break;
1812     case 9:
1813       var $52=$2;
1814       var $53=(($52+44)|0);
1815       var $54=HEAP32[(($53)>>2)];
1816       var $55=((($54)+(1))|0);
1817       HEAP32[(($53)>>2)]=$55;
1818       var $56=$2;
1819       var $57=(($56+40)|0);
1820       var $58=HEAP32[(($57)>>2)];
1821       var $59=(($58+($54)*(36))|0);
1822       var $60=$59;
1823       var $61=$f;
1824       assert(36 % 1 === 0, 'memcpy given ' + 36 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');for (var $$src = $61>>2, $$dest = $60>>2, $$stop = $$src + 9; $$src < $$stop; $$src++, $$dest++) {
1825         HEAP32[$$dest] = HEAP32[$$src]
1826       };
1827       $1=1;
1828       __label__ = 10; break;
1829     case 10:
1830       var $63=$1;
1831       STACKTOP = __stackBase__;
1832       return $63;
1833     default: assert(0, "bad label: " + __label__);
1834   }
1835 }
1836 _qc_program_functions_add["X"]=1;
1837
1838 function _qc_program_strings_remove($self, $idx) {
1839   ;
1840   var __label__;
1841   __label__ = 2;
1842   while(1) switch(__label__) {
1843     case 2:
1844       var $1;
1845       var $2;
1846       var $3;
1847       var $i;
1848       var $reall;
1849       $2=$self;
1850       $3=$idx;
1851       var $4=$3;
1852       var $5=$2;
1853       var $6=(($5+56)|0);
1854       var $7=HEAP32[(($6)>>2)];
1855       var $8=(($4)>>>0) >= (($7)>>>0);
1856       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1857     case 3:
1858       $1=1;
1859       __label__ = 13; break;
1860     case 4:
1861       var $11=$3;
1862       $i=$11;
1863       __label__ = 5; break;
1864     case 5:
1865       var $13=$i;
1866       var $14=$2;
1867       var $15=(($14+56)|0);
1868       var $16=HEAP32[(($15)>>2)];
1869       var $17=((($16)-(1))|0);
1870       var $18=(($13)>>>0) < (($17)>>>0);
1871       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1872     case 6:
1873       var $20=$i;
1874       var $21=((($20)+(1))|0);
1875       var $22=$2;
1876       var $23=(($22+52)|0);
1877       var $24=HEAP32[(($23)>>2)];
1878       var $25=(($24+$21)|0);
1879       var $26=HEAP8[($25)];
1880       var $27=$i;
1881       var $28=$2;
1882       var $29=(($28+52)|0);
1883       var $30=HEAP32[(($29)>>2)];
1884       var $31=(($30+$27)|0);
1885       HEAP8[($31)]=$26;
1886       __label__ = 7; break;
1887     case 7:
1888       var $33=$i;
1889       var $34=((($33)+(1))|0);
1890       $i=$34;
1891       __label__ = 5; break;
1892     case 8:
1893       var $36=$2;
1894       var $37=(($36+56)|0);
1895       var $38=HEAP32[(($37)>>2)];
1896       var $39=((($38)-(1))|0);
1897       HEAP32[(($37)>>2)]=$39;
1898       var $40=$2;
1899       var $41=(($40+56)|0);
1900       var $42=HEAP32[(($41)>>2)];
1901       var $43=$2;
1902       var $44=(($43+56)|0);
1903       var $45=HEAP32[(($44)>>2)];
1904       var $46=Math.floor(((($45)>>>0))/(2));
1905       var $47=(($42)>>>0) < (($46)>>>0);
1906       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
1907     case 9:
1908       var $49=$2;
1909       var $50=(($49+60)|0);
1910       var $51=HEAP32[(($50)>>2)];
1911       var $52=Math.floor(((($51)>>>0))/(2));
1912       HEAP32[(($50)>>2)]=$52;
1913       var $53=$2;
1914       var $54=(($53+56)|0);
1915       var $55=HEAP32[(($54)>>2)];
1916       var $56=(($55)|0);
1917       var $57=_util_memory_a($56, 36, ((STRING_TABLE.__str)|0));
1918       $reall=$57;
1919       var $58=$reall;
1920       var $59=(($58)|0)!=0;
1921       if ($59) { __label__ = 11; break; } else { __label__ = 10; break; }
1922     case 10:
1923       $1=0;
1924       __label__ = 13; break;
1925     case 11:
1926       var $62=$reall;
1927       var $63=$2;
1928       var $64=(($63+52)|0);
1929       var $65=HEAP32[(($64)>>2)];
1930       var $66=$2;
1931       var $67=(($66+56)|0);
1932       var $68=HEAP32[(($67)>>2)];
1933       var $69=(($68)|0);
1934       assert($69 % 1 === 0, 'memcpy given ' + $69 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($62, $65, $69, 1);
1935       var $70=$2;
1936       var $71=(($70+52)|0);
1937       var $72=HEAP32[(($71)>>2)];
1938       _util_memory_d($72, 36, ((STRING_TABLE.__str)|0));
1939       var $73=$reall;
1940       var $74=$2;
1941       var $75=(($74+52)|0);
1942       HEAP32[(($75)>>2)]=$73;
1943       __label__ = 12; break;
1944     case 12:
1945       $1=1;
1946       __label__ = 13; break;
1947     case 13:
1948       var $78=$1;
1949       ;
1950       return $78;
1951     default: assert(0, "bad label: " + __label__);
1952   }
1953 }
1954 _qc_program_strings_remove["X"]=1;
1955
1956 function _qc_program_strings_add($self, $f) {
1957   ;
1958   var __label__;
1959   __label__ = 2;
1960   while(1) switch(__label__) {
1961     case 2:
1962       var $1;
1963       var $2;
1964       var $3;
1965       var $reall;
1966       $2=$self;
1967       $3=$f;
1968       var $4=$2;
1969       var $5=(($4+56)|0);
1970       var $6=HEAP32[(($5)>>2)];
1971       var $7=$2;
1972       var $8=(($7+60)|0);
1973       var $9=HEAP32[(($8)>>2)];
1974       var $10=(($6)|0)==(($9)|0);
1975       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
1976     case 3:
1977       var $12=$2;
1978       var $13=(($12+60)|0);
1979       var $14=HEAP32[(($13)>>2)];
1980       var $15=(($14)|0)!=0;
1981       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
1982     case 4:
1983       var $17=$2;
1984       var $18=(($17+60)|0);
1985       HEAP32[(($18)>>2)]=16;
1986       __label__ = 6; break;
1987     case 5:
1988       var $20=$2;
1989       var $21=(($20+60)|0);
1990       var $22=HEAP32[(($21)>>2)];
1991       var $23=((($22<<1))|0);
1992       HEAP32[(($21)>>2)]=$23;
1993       __label__ = 6; break;
1994     case 6:
1995       var $25=$2;
1996       var $26=(($25+60)|0);
1997       var $27=HEAP32[(($26)>>2)];
1998       var $28=(($27)|0);
1999       var $29=_util_memory_a($28, 36, ((STRING_TABLE.__str)|0));
2000       $reall=$29;
2001       var $30=$reall;
2002       var $31=(($30)|0)!=0;
2003       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
2004     case 7:
2005       $1=0;
2006       __label__ = 10; break;
2007     case 8:
2008       var $34=$reall;
2009       var $35=$2;
2010       var $36=(($35+52)|0);
2011       var $37=HEAP32[(($36)>>2)];
2012       var $38=$2;
2013       var $39=(($38+56)|0);
2014       var $40=HEAP32[(($39)>>2)];
2015       var $41=(($40)|0);
2016       assert($41 % 1 === 0, 'memcpy given ' + $41 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($34, $37, $41, 1);
2017       var $42=$2;
2018       var $43=(($42+52)|0);
2019       var $44=HEAP32[(($43)>>2)];
2020       _util_memory_d($44, 36, ((STRING_TABLE.__str)|0));
2021       var $45=$reall;
2022       var $46=$2;
2023       var $47=(($46+52)|0);
2024       HEAP32[(($47)>>2)]=$45;
2025       __label__ = 9; break;
2026     case 9:
2027       var $49=$3;
2028       var $50=$2;
2029       var $51=(($50+56)|0);
2030       var $52=HEAP32[(($51)>>2)];
2031       var $53=((($52)+(1))|0);
2032       HEAP32[(($51)>>2)]=$53;
2033       var $54=$2;
2034       var $55=(($54+52)|0);
2035       var $56=HEAP32[(($55)>>2)];
2036       var $57=(($56+$52)|0);
2037       HEAP8[($57)]=$49;
2038       $1=1;
2039       __label__ = 10; break;
2040     case 10:
2041       var $59=$1;
2042       ;
2043       return $59;
2044     default: assert(0, "bad label: " + __label__);
2045   }
2046 }
2047 _qc_program_strings_add["X"]=1;
2048
2049 function _qc_program_strings_append($s, $p, $c) {
2050   ;
2051   var __label__;
2052   __label__ = 2;
2053   while(1) switch(__label__) {
2054     case 2:
2055       var $1;
2056       var $2;
2057       var $3;
2058       var $4;
2059       var $reall;
2060       var $oldalloc;
2061       $2=$s;
2062       $3=$p;
2063       $4=$c;
2064       var $5=$2;
2065       var $6=(($5+56)|0);
2066       var $7=HEAP32[(($6)>>2)];
2067       var $8=$4;
2068       var $9=((($7)+($8))|0);
2069       var $10=$2;
2070       var $11=(($10+60)|0);
2071       var $12=HEAP32[(($11)>>2)];
2072       var $13=(($9)>>>0) > (($12)>>>0);
2073       if ($13) { __label__ = 3; break; } else { __label__ = 14; break; }
2074     case 3:
2075       var $15=$2;
2076       var $16=(($15+60)|0);
2077       var $17=HEAP32[(($16)>>2)];
2078       var $18=(($17)|0)!=0;
2079       if ($18) { __label__ = 8; break; } else { __label__ = 4; break; }
2080     case 4:
2081       var $20=$4;
2082       var $21=(($20)>>>0) < 16;
2083       if ($21) { __label__ = 5; break; } else { __label__ = 6; break; }
2084     case 5:
2085       var $26 = 16;__label__ = 7; break;
2086     case 6:
2087       var $24=$4;
2088       var $26 = $24;__label__ = 7; break;
2089     case 7:
2090       var $26;
2091       var $27=$2;
2092       var $28=(($27+60)|0);
2093       HEAP32[(($28)>>2)]=$26;
2094       var $29=$2;
2095       var $30=(($29+60)|0);
2096       var $31=HEAP32[(($30)>>2)];
2097       var $32=(($31)|0);
2098       var $33=_util_memory_a($32, 37, ((STRING_TABLE.__str)|0));
2099       var $34=$2;
2100       var $35=(($34+52)|0);
2101       HEAP32[(($35)>>2)]=$33;
2102       __label__ = 13; break;
2103     case 8:
2104       var $37=$2;
2105       var $38=(($37+60)|0);
2106       var $39=HEAP32[(($38)>>2)];
2107       $oldalloc=$39;
2108       var $40=$2;
2109       var $41=(($40+60)|0);
2110       var $42=HEAP32[(($41)>>2)];
2111       var $43=((($42<<1))|0);
2112       HEAP32[(($41)>>2)]=$43;
2113       var $44=$2;
2114       var $45=(($44+56)|0);
2115       var $46=HEAP32[(($45)>>2)];
2116       var $47=$4;
2117       var $48=((($46)+($47))|0);
2118       var $49=$2;
2119       var $50=(($49+60)|0);
2120       var $51=HEAP32[(($50)>>2)];
2121       var $52=(($48)>>>0) >= (($51)>>>0);
2122       if ($52) { __label__ = 9; break; } else { __label__ = 10; break; }
2123     case 9:
2124       var $54=$2;
2125       var $55=(($54+56)|0);
2126       var $56=HEAP32[(($55)>>2)];
2127       var $57=$4;
2128       var $58=((($56)+($57))|0);
2129       var $59=$2;
2130       var $60=(($59+60)|0);
2131       HEAP32[(($60)>>2)]=$58;
2132       __label__ = 10; break;
2133     case 10:
2134       var $62=$2;
2135       var $63=(($62+60)|0);
2136       var $64=HEAP32[(($63)>>2)];
2137       var $65=(($64)|0);
2138       var $66=_util_memory_a($65, 37, ((STRING_TABLE.__str)|0));
2139       $reall=$66;
2140       var $67=$reall;
2141       var $68=(($67)|0)!=0;
2142       if ($68) { __label__ = 12; break; } else { __label__ = 11; break; }
2143     case 11:
2144       var $70=$oldalloc;
2145       var $71=$2;
2146       var $72=(($71+60)|0);
2147       HEAP32[(($72)>>2)]=$70;
2148       $1=0;
2149       __label__ = 15; break;
2150     case 12:
2151       var $74=$reall;
2152       var $75=$2;
2153       var $76=(($75+52)|0);
2154       var $77=HEAP32[(($76)>>2)];
2155       var $78=$2;
2156       var $79=(($78+56)|0);
2157       var $80=HEAP32[(($79)>>2)];
2158       var $81=(($80)|0);
2159       assert($81 % 1 === 0, 'memcpy given ' + $81 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($74, $77, $81, 1);
2160       var $82=$2;
2161       var $83=(($82+52)|0);
2162       var $84=HEAP32[(($83)>>2)];
2163       _util_memory_d($84, 37, ((STRING_TABLE.__str)|0));
2164       var $85=$reall;
2165       var $86=$2;
2166       var $87=(($86+52)|0);
2167       HEAP32[(($87)>>2)]=$85;
2168       __label__ = 13; break;
2169     case 13:
2170       __label__ = 14; break;
2171     case 14:
2172       var $90=$2;
2173       var $91=(($90+56)|0);
2174       var $92=HEAP32[(($91)>>2)];
2175       var $93=$2;
2176       var $94=(($93+52)|0);
2177       var $95=HEAP32[(($94)>>2)];
2178       var $96=(($95+$92)|0);
2179       var $97=$3;
2180       var $98=$4;
2181       var $99=(($98)|0);
2182       assert($99 % 1 === 0, 'memcpy given ' + $99 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($96, $97, $99, 1);
2183       var $100=$4;
2184       var $101=$2;
2185       var $102=(($101+56)|0);
2186       var $103=HEAP32[(($102)>>2)];
2187       var $104=((($103)+($100))|0);
2188       HEAP32[(($102)>>2)]=$104;
2189       $1=1;
2190       __label__ = 15; break;
2191     case 15:
2192       var $106=$1;
2193       ;
2194       return $106;
2195     default: assert(0, "bad label: " + __label__);
2196   }
2197 }
2198 _qc_program_strings_append["X"]=1;
2199
2200 function _qc_program_strings_resize($s, $c) {
2201   ;
2202   var __label__;
2203   __label__ = 2;
2204   while(1) switch(__label__) {
2205     case 2:
2206       var $1;
2207       var $2;
2208       var $3;
2209       var $reall;
2210       $2=$s;
2211       $3=$c;
2212       var $4=$3;
2213       var $5=$2;
2214       var $6=(($5+60)|0);
2215       var $7=HEAP32[(($6)>>2)];
2216       var $8=(($4)>>>0) > (($7)>>>0);
2217       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
2218     case 3:
2219       var $10=$3;
2220       var $11=(($10)|0);
2221       var $12=_util_memory_a($11, 38, ((STRING_TABLE.__str)|0));
2222       $reall=$12;
2223       var $13=$reall;
2224       var $14=(($13)|0)!=0;
2225       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
2226     case 4:
2227       $1=0;
2228       __label__ = 11; break;
2229     case 5:
2230       var $17=$reall;
2231       var $18=$2;
2232       var $19=(($18+52)|0);
2233       var $20=HEAP32[(($19)>>2)];
2234       var $21=$2;
2235       var $22=(($21+56)|0);
2236       var $23=HEAP32[(($22)>>2)];
2237       var $24=(($23)|0);
2238       assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($17, $20, $24, 1);
2239       var $25=$3;
2240       var $26=$2;
2241       var $27=(($26+60)|0);
2242       HEAP32[(($27)>>2)]=$25;
2243       var $28=$3;
2244       var $29=$2;
2245       var $30=(($29+56)|0);
2246       HEAP32[(($30)>>2)]=$28;
2247       var $31=$2;
2248       var $32=(($31+52)|0);
2249       var $33=HEAP32[(($32)>>2)];
2250       _util_memory_d($33, 38, ((STRING_TABLE.__str)|0));
2251       var $34=$reall;
2252       var $35=$2;
2253       var $36=(($35+52)|0);
2254       HEAP32[(($36)>>2)]=$34;
2255       $1=1;
2256       __label__ = 11; break;
2257     case 6:
2258       var $38=$3;
2259       var $39=$2;
2260       var $40=(($39+56)|0);
2261       HEAP32[(($40)>>2)]=$38;
2262       var $41=$3;
2263       var $42=$2;
2264       var $43=(($42+60)|0);
2265       var $44=HEAP32[(($43)>>2)];
2266       var $45=Math.floor(((($44)>>>0))/(2));
2267       var $46=(($41)>>>0) < (($45)>>>0);
2268       if ($46) { __label__ = 7; break; } else { __label__ = 10; break; }
2269     case 7:
2270       var $48=$3;
2271       var $49=(($48)|0);
2272       var $50=_util_memory_a($49, 38, ((STRING_TABLE.__str)|0));
2273       $reall=$50;
2274       var $51=$reall;
2275       var $52=(($51)|0)!=0;
2276       if ($52) { __label__ = 9; break; } else { __label__ = 8; break; }
2277     case 8:
2278       $1=0;
2279       __label__ = 11; break;
2280     case 9:
2281       var $55=$reall;
2282       var $56=$2;
2283       var $57=(($56+52)|0);
2284       var $58=HEAP32[(($57)>>2)];
2285       var $59=$3;
2286       var $60=(($59)|0);
2287       assert($60 % 1 === 0, 'memcpy given ' + $60 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($55, $58, $60, 1);
2288       var $61=$2;
2289       var $62=(($61+52)|0);
2290       var $63=HEAP32[(($62)>>2)];
2291       _util_memory_d($63, 38, ((STRING_TABLE.__str)|0));
2292       var $64=$reall;
2293       var $65=$2;
2294       var $66=(($65+52)|0);
2295       HEAP32[(($66)>>2)]=$64;
2296       var $67=$3;
2297       var $68=$2;
2298       var $69=(($68+60)|0);
2299       HEAP32[(($69)>>2)]=$67;
2300       __label__ = 10; break;
2301     case 10:
2302       $1=1;
2303       __label__ = 11; break;
2304     case 11:
2305       var $72=$1;
2306       ;
2307       return $72;
2308     default: assert(0, "bad label: " + __label__);
2309   }
2310 }
2311 _qc_program_strings_resize["X"]=1;
2312
2313 function _qc_program_globals_remove($self, $idx) {
2314   ;
2315   var __label__;
2316   __label__ = 2;
2317   while(1) switch(__label__) {
2318     case 2:
2319       var $1;
2320       var $2;
2321       var $3;
2322       var $i;
2323       var $reall;
2324       $2=$self;
2325       $3=$idx;
2326       var $4=$3;
2327       var $5=$2;
2328       var $6=(($5+68)|0);
2329       var $7=HEAP32[(($6)>>2)];
2330       var $8=(($4)>>>0) >= (($7)>>>0);
2331       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2332     case 3:
2333       $1=1;
2334       __label__ = 13; break;
2335     case 4:
2336       var $11=$3;
2337       $i=$11;
2338       __label__ = 5; break;
2339     case 5:
2340       var $13=$i;
2341       var $14=$2;
2342       var $15=(($14+68)|0);
2343       var $16=HEAP32[(($15)>>2)];
2344       var $17=((($16)-(1))|0);
2345       var $18=(($13)>>>0) < (($17)>>>0);
2346       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2347     case 6:
2348       var $20=$i;
2349       var $21=((($20)+(1))|0);
2350       var $22=$2;
2351       var $23=(($22+64)|0);
2352       var $24=HEAP32[(($23)>>2)];
2353       var $25=(($24+($21<<2))|0);
2354       var $26=HEAP32[(($25)>>2)];
2355       var $27=$i;
2356       var $28=$2;
2357       var $29=(($28+64)|0);
2358       var $30=HEAP32[(($29)>>2)];
2359       var $31=(($30+($27<<2))|0);
2360       HEAP32[(($31)>>2)]=$26;
2361       __label__ = 7; break;
2362     case 7:
2363       var $33=$i;
2364       var $34=((($33)+(1))|0);
2365       $i=$34;
2366       __label__ = 5; break;
2367     case 8:
2368       var $36=$2;
2369       var $37=(($36+68)|0);
2370       var $38=HEAP32[(($37)>>2)];
2371       var $39=((($38)-(1))|0);
2372       HEAP32[(($37)>>2)]=$39;
2373       var $40=$2;
2374       var $41=(($40+68)|0);
2375       var $42=HEAP32[(($41)>>2)];
2376       var $43=$2;
2377       var $44=(($43+68)|0);
2378       var $45=HEAP32[(($44)>>2)];
2379       var $46=Math.floor(((($45)>>>0))/(2));
2380       var $47=(($42)>>>0) < (($46)>>>0);
2381       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
2382     case 9:
2383       var $49=$2;
2384       var $50=(($49+72)|0);
2385       var $51=HEAP32[(($50)>>2)];
2386       var $52=Math.floor(((($51)>>>0))/(2));
2387       HEAP32[(($50)>>2)]=$52;
2388       var $53=$2;
2389       var $54=(($53+68)|0);
2390       var $55=HEAP32[(($54)>>2)];
2391       var $56=((($55<<2))|0);
2392       var $57=_util_memory_a($56, 39, ((STRING_TABLE.__str)|0));
2393       var $58=$57;
2394       $reall=$58;
2395       var $59=$reall;
2396       var $60=(($59)|0)!=0;
2397       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
2398     case 10:
2399       $1=0;
2400       __label__ = 13; break;
2401     case 11:
2402       var $63=$reall;
2403       var $64=$63;
2404       var $65=$2;
2405       var $66=(($65+64)|0);
2406       var $67=HEAP32[(($66)>>2)];
2407       var $68=$67;
2408       var $69=$2;
2409       var $70=(($69+68)|0);
2410       var $71=HEAP32[(($70)>>2)];
2411       var $72=((($71<<2))|0);
2412       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
2413       var $73=$2;
2414       var $74=(($73+64)|0);
2415       var $75=HEAP32[(($74)>>2)];
2416       var $76=$75;
2417       _util_memory_d($76, 39, ((STRING_TABLE.__str)|0));
2418       var $77=$reall;
2419       var $78=$2;
2420       var $79=(($78+64)|0);
2421       HEAP32[(($79)>>2)]=$77;
2422       __label__ = 12; break;
2423     case 12:
2424       $1=1;
2425       __label__ = 13; break;
2426     case 13:
2427       var $82=$1;
2428       ;
2429       return $82;
2430     default: assert(0, "bad label: " + __label__);
2431   }
2432 }
2433 _qc_program_globals_remove["X"]=1;
2434
2435 function _qc_program_globals_add($self, $f) {
2436   ;
2437   var __label__;
2438   __label__ = 2;
2439   while(1) switch(__label__) {
2440     case 2:
2441       var $1;
2442       var $2;
2443       var $3;
2444       var $reall;
2445       $2=$self;
2446       $3=$f;
2447       var $4=$2;
2448       var $5=(($4+68)|0);
2449       var $6=HEAP32[(($5)>>2)];
2450       var $7=$2;
2451       var $8=(($7+72)|0);
2452       var $9=HEAP32[(($8)>>2)];
2453       var $10=(($6)|0)==(($9)|0);
2454       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
2455     case 3:
2456       var $12=$2;
2457       var $13=(($12+72)|0);
2458       var $14=HEAP32[(($13)>>2)];
2459       var $15=(($14)|0)!=0;
2460       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
2461     case 4:
2462       var $17=$2;
2463       var $18=(($17+72)|0);
2464       HEAP32[(($18)>>2)]=16;
2465       __label__ = 6; break;
2466     case 5:
2467       var $20=$2;
2468       var $21=(($20+72)|0);
2469       var $22=HEAP32[(($21)>>2)];
2470       var $23=((($22<<1))|0);
2471       HEAP32[(($21)>>2)]=$23;
2472       __label__ = 6; break;
2473     case 6:
2474       var $25=$2;
2475       var $26=(($25+72)|0);
2476       var $27=HEAP32[(($26)>>2)];
2477       var $28=((($27<<2))|0);
2478       var $29=_util_memory_a($28, 39, ((STRING_TABLE.__str)|0));
2479       var $30=$29;
2480       $reall=$30;
2481       var $31=$reall;
2482       var $32=(($31)|0)!=0;
2483       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2484     case 7:
2485       $1=0;
2486       __label__ = 10; break;
2487     case 8:
2488       var $35=$reall;
2489       var $36=$35;
2490       var $37=$2;
2491       var $38=(($37+64)|0);
2492       var $39=HEAP32[(($38)>>2)];
2493       var $40=$39;
2494       var $41=$2;
2495       var $42=(($41+68)|0);
2496       var $43=HEAP32[(($42)>>2)];
2497       var $44=((($43<<2))|0);
2498       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
2499       var $45=$2;
2500       var $46=(($45+64)|0);
2501       var $47=HEAP32[(($46)>>2)];
2502       var $48=$47;
2503       _util_memory_d($48, 39, ((STRING_TABLE.__str)|0));
2504       var $49=$reall;
2505       var $50=$2;
2506       var $51=(($50+64)|0);
2507       HEAP32[(($51)>>2)]=$49;
2508       __label__ = 9; break;
2509     case 9:
2510       var $53=$3;
2511       var $54=$2;
2512       var $55=(($54+68)|0);
2513       var $56=HEAP32[(($55)>>2)];
2514       var $57=((($56)+(1))|0);
2515       HEAP32[(($55)>>2)]=$57;
2516       var $58=$2;
2517       var $59=(($58+64)|0);
2518       var $60=HEAP32[(($59)>>2)];
2519       var $61=(($60+($56<<2))|0);
2520       HEAP32[(($61)>>2)]=$53;
2521       $1=1;
2522       __label__ = 10; break;
2523     case 10:
2524       var $63=$1;
2525       ;
2526       return $63;
2527     default: assert(0, "bad label: " + __label__);
2528   }
2529 }
2530 _qc_program_globals_add["X"]=1;
2531
2532 function _qc_program_entitydata_remove($self, $idx) {
2533   ;
2534   var __label__;
2535   __label__ = 2;
2536   while(1) switch(__label__) {
2537     case 2:
2538       var $1;
2539       var $2;
2540       var $3;
2541       var $i;
2542       var $reall;
2543       $2=$self;
2544       $3=$idx;
2545       var $4=$3;
2546       var $5=$2;
2547       var $6=(($5+80)|0);
2548       var $7=HEAP32[(($6)>>2)];
2549       var $8=(($4)>>>0) >= (($7)>>>0);
2550       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2551     case 3:
2552       $1=1;
2553       __label__ = 13; break;
2554     case 4:
2555       var $11=$3;
2556       $i=$11;
2557       __label__ = 5; break;
2558     case 5:
2559       var $13=$i;
2560       var $14=$2;
2561       var $15=(($14+80)|0);
2562       var $16=HEAP32[(($15)>>2)];
2563       var $17=((($16)-(1))|0);
2564       var $18=(($13)>>>0) < (($17)>>>0);
2565       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2566     case 6:
2567       var $20=$i;
2568       var $21=((($20)+(1))|0);
2569       var $22=$2;
2570       var $23=(($22+76)|0);
2571       var $24=HEAP32[(($23)>>2)];
2572       var $25=(($24+($21<<2))|0);
2573       var $26=HEAP32[(($25)>>2)];
2574       var $27=$i;
2575       var $28=$2;
2576       var $29=(($28+76)|0);
2577       var $30=HEAP32[(($29)>>2)];
2578       var $31=(($30+($27<<2))|0);
2579       HEAP32[(($31)>>2)]=$26;
2580       __label__ = 7; break;
2581     case 7:
2582       var $33=$i;
2583       var $34=((($33)+(1))|0);
2584       $i=$34;
2585       __label__ = 5; break;
2586     case 8:
2587       var $36=$2;
2588       var $37=(($36+80)|0);
2589       var $38=HEAP32[(($37)>>2)];
2590       var $39=((($38)-(1))|0);
2591       HEAP32[(($37)>>2)]=$39;
2592       var $40=$2;
2593       var $41=(($40+80)|0);
2594       var $42=HEAP32[(($41)>>2)];
2595       var $43=$2;
2596       var $44=(($43+80)|0);
2597       var $45=HEAP32[(($44)>>2)];
2598       var $46=Math.floor(((($45)>>>0))/(2));
2599       var $47=(($42)>>>0) < (($46)>>>0);
2600       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
2601     case 9:
2602       var $49=$2;
2603       var $50=(($49+84)|0);
2604       var $51=HEAP32[(($50)>>2)];
2605       var $52=Math.floor(((($51)>>>0))/(2));
2606       HEAP32[(($50)>>2)]=$52;
2607       var $53=$2;
2608       var $54=(($53+80)|0);
2609       var $55=HEAP32[(($54)>>2)];
2610       var $56=((($55<<2))|0);
2611       var $57=_util_memory_a($56, 40, ((STRING_TABLE.__str)|0));
2612       var $58=$57;
2613       $reall=$58;
2614       var $59=$reall;
2615       var $60=(($59)|0)!=0;
2616       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
2617     case 10:
2618       $1=0;
2619       __label__ = 13; break;
2620     case 11:
2621       var $63=$reall;
2622       var $64=$63;
2623       var $65=$2;
2624       var $66=(($65+76)|0);
2625       var $67=HEAP32[(($66)>>2)];
2626       var $68=$67;
2627       var $69=$2;
2628       var $70=(($69+80)|0);
2629       var $71=HEAP32[(($70)>>2)];
2630       var $72=((($71<<2))|0);
2631       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
2632       var $73=$2;
2633       var $74=(($73+76)|0);
2634       var $75=HEAP32[(($74)>>2)];
2635       var $76=$75;
2636       _util_memory_d($76, 40, ((STRING_TABLE.__str)|0));
2637       var $77=$reall;
2638       var $78=$2;
2639       var $79=(($78+76)|0);
2640       HEAP32[(($79)>>2)]=$77;
2641       __label__ = 12; break;
2642     case 12:
2643       $1=1;
2644       __label__ = 13; break;
2645     case 13:
2646       var $82=$1;
2647       ;
2648       return $82;
2649     default: assert(0, "bad label: " + __label__);
2650   }
2651 }
2652 _qc_program_entitydata_remove["X"]=1;
2653
2654 function _qc_program_entitydata_add($self, $f) {
2655   ;
2656   var __label__;
2657   __label__ = 2;
2658   while(1) switch(__label__) {
2659     case 2:
2660       var $1;
2661       var $2;
2662       var $3;
2663       var $reall;
2664       $2=$self;
2665       $3=$f;
2666       var $4=$2;
2667       var $5=(($4+80)|0);
2668       var $6=HEAP32[(($5)>>2)];
2669       var $7=$2;
2670       var $8=(($7+84)|0);
2671       var $9=HEAP32[(($8)>>2)];
2672       var $10=(($6)|0)==(($9)|0);
2673       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
2674     case 3:
2675       var $12=$2;
2676       var $13=(($12+84)|0);
2677       var $14=HEAP32[(($13)>>2)];
2678       var $15=(($14)|0)!=0;
2679       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
2680     case 4:
2681       var $17=$2;
2682       var $18=(($17+84)|0);
2683       HEAP32[(($18)>>2)]=16;
2684       __label__ = 6; break;
2685     case 5:
2686       var $20=$2;
2687       var $21=(($20+84)|0);
2688       var $22=HEAP32[(($21)>>2)];
2689       var $23=((($22<<1))|0);
2690       HEAP32[(($21)>>2)]=$23;
2691       __label__ = 6; break;
2692     case 6:
2693       var $25=$2;
2694       var $26=(($25+84)|0);
2695       var $27=HEAP32[(($26)>>2)];
2696       var $28=((($27<<2))|0);
2697       var $29=_util_memory_a($28, 40, ((STRING_TABLE.__str)|0));
2698       var $30=$29;
2699       $reall=$30;
2700       var $31=$reall;
2701       var $32=(($31)|0)!=0;
2702       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2703     case 7:
2704       $1=0;
2705       __label__ = 10; break;
2706     case 8:
2707       var $35=$reall;
2708       var $36=$35;
2709       var $37=$2;
2710       var $38=(($37+76)|0);
2711       var $39=HEAP32[(($38)>>2)];
2712       var $40=$39;
2713       var $41=$2;
2714       var $42=(($41+80)|0);
2715       var $43=HEAP32[(($42)>>2)];
2716       var $44=((($43<<2))|0);
2717       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
2718       var $45=$2;
2719       var $46=(($45+76)|0);
2720       var $47=HEAP32[(($46)>>2)];
2721       var $48=$47;
2722       _util_memory_d($48, 40, ((STRING_TABLE.__str)|0));
2723       var $49=$reall;
2724       var $50=$2;
2725       var $51=(($50+76)|0);
2726       HEAP32[(($51)>>2)]=$49;
2727       __label__ = 9; break;
2728     case 9:
2729       var $53=$3;
2730       var $54=$2;
2731       var $55=(($54+80)|0);
2732       var $56=HEAP32[(($55)>>2)];
2733       var $57=((($56)+(1))|0);
2734       HEAP32[(($55)>>2)]=$57;
2735       var $58=$2;
2736       var $59=(($58+76)|0);
2737       var $60=HEAP32[(($59)>>2)];
2738       var $61=(($60+($56<<2))|0);
2739       HEAP32[(($61)>>2)]=$53;
2740       $1=1;
2741       __label__ = 10; break;
2742     case 10:
2743       var $63=$1;
2744       ;
2745       return $63;
2746     default: assert(0, "bad label: " + __label__);
2747   }
2748 }
2749 _qc_program_entitydata_add["X"]=1;
2750
2751 function _qc_program_entitypool_remove($self, $idx) {
2752   ;
2753   var __label__;
2754   __label__ = 2;
2755   while(1) switch(__label__) {
2756     case 2:
2757       var $1;
2758       var $2;
2759       var $3;
2760       var $i;
2761       var $reall;
2762       $2=$self;
2763       $3=$idx;
2764       var $4=$3;
2765       var $5=$2;
2766       var $6=(($5+92)|0);
2767       var $7=HEAP32[(($6)>>2)];
2768       var $8=(($4)>>>0) >= (($7)>>>0);
2769       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2770     case 3:
2771       $1=1;
2772       __label__ = 13; break;
2773     case 4:
2774       var $11=$3;
2775       $i=$11;
2776       __label__ = 5; break;
2777     case 5:
2778       var $13=$i;
2779       var $14=$2;
2780       var $15=(($14+92)|0);
2781       var $16=HEAP32[(($15)>>2)];
2782       var $17=((($16)-(1))|0);
2783       var $18=(($13)>>>0) < (($17)>>>0);
2784       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2785     case 6:
2786       var $20=$i;
2787       var $21=((($20)+(1))|0);
2788       var $22=$2;
2789       var $23=(($22+88)|0);
2790       var $24=HEAP32[(($23)>>2)];
2791       var $25=(($24+$21)|0);
2792       var $26=HEAP8[($25)];
2793       var $27=(($26) & 1);
2794       var $28=$i;
2795       var $29=$2;
2796       var $30=(($29+88)|0);
2797       var $31=HEAP32[(($30)>>2)];
2798       var $32=(($31+$28)|0);
2799       var $33=(($27)&1);
2800       HEAP8[($32)]=$33;
2801       __label__ = 7; break;
2802     case 7:
2803       var $35=$i;
2804       var $36=((($35)+(1))|0);
2805       $i=$36;
2806       __label__ = 5; break;
2807     case 8:
2808       var $38=$2;
2809       var $39=(($38+92)|0);
2810       var $40=HEAP32[(($39)>>2)];
2811       var $41=((($40)-(1))|0);
2812       HEAP32[(($39)>>2)]=$41;
2813       var $42=$2;
2814       var $43=(($42+92)|0);
2815       var $44=HEAP32[(($43)>>2)];
2816       var $45=$2;
2817       var $46=(($45+92)|0);
2818       var $47=HEAP32[(($46)>>2)];
2819       var $48=Math.floor(((($47)>>>0))/(2));
2820       var $49=(($44)>>>0) < (($48)>>>0);
2821       if ($49) { __label__ = 9; break; } else { __label__ = 12; break; }
2822     case 9:
2823       var $51=$2;
2824       var $52=(($51+96)|0);
2825       var $53=HEAP32[(($52)>>2)];
2826       var $54=Math.floor(((($53)>>>0))/(2));
2827       HEAP32[(($52)>>2)]=$54;
2828       var $55=$2;
2829       var $56=(($55+92)|0);
2830       var $57=HEAP32[(($56)>>2)];
2831       var $58=(($57)|0);
2832       var $59=_util_memory_a($58, 41, ((STRING_TABLE.__str)|0));
2833       $reall=$59;
2834       var $60=$reall;
2835       var $61=(($60)|0)!=0;
2836       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
2837     case 10:
2838       $1=0;
2839       __label__ = 13; break;
2840     case 11:
2841       var $64=$reall;
2842       var $65=$2;
2843       var $66=(($65+88)|0);
2844       var $67=HEAP32[(($66)>>2)];
2845       var $68=$2;
2846       var $69=(($68+92)|0);
2847       var $70=HEAP32[(($69)>>2)];
2848       var $71=(($70)|0);
2849       assert($71 % 1 === 0, 'memcpy given ' + $71 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $67, $71, 1);
2850       var $72=$2;
2851       var $73=(($72+88)|0);
2852       var $74=HEAP32[(($73)>>2)];
2853       _util_memory_d($74, 41, ((STRING_TABLE.__str)|0));
2854       var $75=$reall;
2855       var $76=$2;
2856       var $77=(($76+88)|0);
2857       HEAP32[(($77)>>2)]=$75;
2858       __label__ = 12; break;
2859     case 12:
2860       $1=1;
2861       __label__ = 13; break;
2862     case 13:
2863       var $80=$1;
2864       ;
2865       return $80;
2866     default: assert(0, "bad label: " + __label__);
2867   }
2868 }
2869 _qc_program_entitypool_remove["X"]=1;
2870
2871 function _qc_program_entitypool_add($self, $f) {
2872   ;
2873   var __label__;
2874   __label__ = 2;
2875   while(1) switch(__label__) {
2876     case 2:
2877       var $1;
2878       var $2;
2879       var $3;
2880       var $reall;
2881       $2=$self;
2882       var $4=(($f)&1);
2883       $3=$4;
2884       var $5=$2;
2885       var $6=(($5+92)|0);
2886       var $7=HEAP32[(($6)>>2)];
2887       var $8=$2;
2888       var $9=(($8+96)|0);
2889       var $10=HEAP32[(($9)>>2)];
2890       var $11=(($7)|0)==(($10)|0);
2891       if ($11) { __label__ = 3; break; } else { __label__ = 9; break; }
2892     case 3:
2893       var $13=$2;
2894       var $14=(($13+96)|0);
2895       var $15=HEAP32[(($14)>>2)];
2896       var $16=(($15)|0)!=0;
2897       if ($16) { __label__ = 5; break; } else { __label__ = 4; break; }
2898     case 4:
2899       var $18=$2;
2900       var $19=(($18+96)|0);
2901       HEAP32[(($19)>>2)]=16;
2902       __label__ = 6; break;
2903     case 5:
2904       var $21=$2;
2905       var $22=(($21+96)|0);
2906       var $23=HEAP32[(($22)>>2)];
2907       var $24=((($23<<1))|0);
2908       HEAP32[(($22)>>2)]=$24;
2909       __label__ = 6; break;
2910     case 6:
2911       var $26=$2;
2912       var $27=(($26+96)|0);
2913       var $28=HEAP32[(($27)>>2)];
2914       var $29=(($28)|0);
2915       var $30=_util_memory_a($29, 41, ((STRING_TABLE.__str)|0));
2916       $reall=$30;
2917       var $31=$reall;
2918       var $32=(($31)|0)!=0;
2919       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2920     case 7:
2921       $1=0;
2922       __label__ = 10; break;
2923     case 8:
2924       var $35=$reall;
2925       var $36=$2;
2926       var $37=(($36+88)|0);
2927       var $38=HEAP32[(($37)>>2)];
2928       var $39=$2;
2929       var $40=(($39+92)|0);
2930       var $41=HEAP32[(($40)>>2)];
2931       var $42=(($41)|0);
2932       assert($42 % 1 === 0, 'memcpy given ' + $42 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $38, $42, 1);
2933       var $43=$2;
2934       var $44=(($43+88)|0);
2935       var $45=HEAP32[(($44)>>2)];
2936       _util_memory_d($45, 41, ((STRING_TABLE.__str)|0));
2937       var $46=$reall;
2938       var $47=$2;
2939       var $48=(($47+88)|0);
2940       HEAP32[(($48)>>2)]=$46;
2941       __label__ = 9; break;
2942     case 9:
2943       var $50=$3;
2944       var $51=(($50) & 1);
2945       var $52=$2;
2946       var $53=(($52+92)|0);
2947       var $54=HEAP32[(($53)>>2)];
2948       var $55=((($54)+(1))|0);
2949       HEAP32[(($53)>>2)]=$55;
2950       var $56=$2;
2951       var $57=(($56+88)|0);
2952       var $58=HEAP32[(($57)>>2)];
2953       var $59=(($58+$54)|0);
2954       var $60=(($51)&1);
2955       HEAP8[($59)]=$60;
2956       $1=1;
2957       __label__ = 10; break;
2958     case 10:
2959       var $62=$1;
2960       ;
2961       return $62;
2962     default: assert(0, "bad label: " + __label__);
2963   }
2964 }
2965 _qc_program_entitypool_add["X"]=1;
2966
2967 function _qc_program_localstack_remove($self, $idx) {
2968   ;
2969   var __label__;
2970   __label__ = 2;
2971   while(1) switch(__label__) {
2972     case 2:
2973       var $1;
2974       var $2;
2975       var $3;
2976       var $i;
2977       var $reall;
2978       $2=$self;
2979       $3=$idx;
2980       var $4=$3;
2981       var $5=$2;
2982       var $6=(($5+156)|0);
2983       var $7=HEAP32[(($6)>>2)];
2984       var $8=(($4)>>>0) >= (($7)>>>0);
2985       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2986     case 3:
2987       $1=1;
2988       __label__ = 13; break;
2989     case 4:
2990       var $11=$3;
2991       $i=$11;
2992       __label__ = 5; break;
2993     case 5:
2994       var $13=$i;
2995       var $14=$2;
2996       var $15=(($14+156)|0);
2997       var $16=HEAP32[(($15)>>2)];
2998       var $17=((($16)-(1))|0);
2999       var $18=(($13)>>>0) < (($17)>>>0);
3000       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3001     case 6:
3002       var $20=$i;
3003       var $21=((($20)+(1))|0);
3004       var $22=$2;
3005       var $23=(($22+152)|0);
3006       var $24=HEAP32[(($23)>>2)];
3007       var $25=(($24+($21<<2))|0);
3008       var $26=HEAP32[(($25)>>2)];
3009       var $27=$i;
3010       var $28=$2;
3011       var $29=(($28+152)|0);
3012       var $30=HEAP32[(($29)>>2)];
3013       var $31=(($30+($27<<2))|0);
3014       HEAP32[(($31)>>2)]=$26;
3015       __label__ = 7; break;
3016     case 7:
3017       var $33=$i;
3018       var $34=((($33)+(1))|0);
3019       $i=$34;
3020       __label__ = 5; break;
3021     case 8:
3022       var $36=$2;
3023       var $37=(($36+156)|0);
3024       var $38=HEAP32[(($37)>>2)];
3025       var $39=((($38)-(1))|0);
3026       HEAP32[(($37)>>2)]=$39;
3027       var $40=$2;
3028       var $41=(($40+156)|0);
3029       var $42=HEAP32[(($41)>>2)];
3030       var $43=$2;
3031       var $44=(($43+156)|0);
3032       var $45=HEAP32[(($44)>>2)];
3033       var $46=Math.floor(((($45)>>>0))/(2));
3034       var $47=(($42)>>>0) < (($46)>>>0);
3035       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
3036     case 9:
3037       var $49=$2;
3038       var $50=(($49+160)|0);
3039       var $51=HEAP32[(($50)>>2)];
3040       var $52=Math.floor(((($51)>>>0))/(2));
3041       HEAP32[(($50)>>2)]=$52;
3042       var $53=$2;
3043       var $54=(($53+156)|0);
3044       var $55=HEAP32[(($54)>>2)];
3045       var $56=((($55<<2))|0);
3046       var $57=_util_memory_a($56, 43, ((STRING_TABLE.__str)|0));
3047       var $58=$57;
3048       $reall=$58;
3049       var $59=$reall;
3050       var $60=(($59)|0)!=0;
3051       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
3052     case 10:
3053       $1=0;
3054       __label__ = 13; break;
3055     case 11:
3056       var $63=$reall;
3057       var $64=$63;
3058       var $65=$2;
3059       var $66=(($65+152)|0);
3060       var $67=HEAP32[(($66)>>2)];
3061       var $68=$67;
3062       var $69=$2;
3063       var $70=(($69+156)|0);
3064       var $71=HEAP32[(($70)>>2)];
3065       var $72=((($71<<2))|0);
3066       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
3067       var $73=$2;
3068       var $74=(($73+152)|0);
3069       var $75=HEAP32[(($74)>>2)];
3070       var $76=$75;
3071       _util_memory_d($76, 43, ((STRING_TABLE.__str)|0));
3072       var $77=$reall;
3073       var $78=$2;
3074       var $79=(($78+152)|0);
3075       HEAP32[(($79)>>2)]=$77;
3076       __label__ = 12; break;
3077     case 12:
3078       $1=1;
3079       __label__ = 13; break;
3080     case 13:
3081       var $82=$1;
3082       ;
3083       return $82;
3084     default: assert(0, "bad label: " + __label__);
3085   }
3086 }
3087 _qc_program_localstack_remove["X"]=1;
3088
3089 function _qc_program_localstack_add($self, $f) {
3090   ;
3091   var __label__;
3092   __label__ = 2;
3093   while(1) switch(__label__) {
3094     case 2:
3095       var $1;
3096       var $2;
3097       var $3;
3098       var $reall;
3099       $2=$self;
3100       $3=$f;
3101       var $4=$2;
3102       var $5=(($4+156)|0);
3103       var $6=HEAP32[(($5)>>2)];
3104       var $7=$2;
3105       var $8=(($7+160)|0);
3106       var $9=HEAP32[(($8)>>2)];
3107       var $10=(($6)|0)==(($9)|0);
3108       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
3109     case 3:
3110       var $12=$2;
3111       var $13=(($12+160)|0);
3112       var $14=HEAP32[(($13)>>2)];
3113       var $15=(($14)|0)!=0;
3114       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3115     case 4:
3116       var $17=$2;
3117       var $18=(($17+160)|0);
3118       HEAP32[(($18)>>2)]=16;
3119       __label__ = 6; break;
3120     case 5:
3121       var $20=$2;
3122       var $21=(($20+160)|0);
3123       var $22=HEAP32[(($21)>>2)];
3124       var $23=((($22<<1))|0);
3125       HEAP32[(($21)>>2)]=$23;
3126       __label__ = 6; break;
3127     case 6:
3128       var $25=$2;
3129       var $26=(($25+160)|0);
3130       var $27=HEAP32[(($26)>>2)];
3131       var $28=((($27<<2))|0);
3132       var $29=_util_memory_a($28, 43, ((STRING_TABLE.__str)|0));
3133       var $30=$29;
3134       $reall=$30;
3135       var $31=$reall;
3136       var $32=(($31)|0)!=0;
3137       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
3138     case 7:
3139       $1=0;
3140       __label__ = 10; break;
3141     case 8:
3142       var $35=$reall;
3143       var $36=$35;
3144       var $37=$2;
3145       var $38=(($37+152)|0);
3146       var $39=HEAP32[(($38)>>2)];
3147       var $40=$39;
3148       var $41=$2;
3149       var $42=(($41+156)|0);
3150       var $43=HEAP32[(($42)>>2)];
3151       var $44=((($43<<2))|0);
3152       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
3153       var $45=$2;
3154       var $46=(($45+152)|0);
3155       var $47=HEAP32[(($46)>>2)];
3156       var $48=$47;
3157       _util_memory_d($48, 43, ((STRING_TABLE.__str)|0));
3158       var $49=$reall;
3159       var $50=$2;
3160       var $51=(($50+152)|0);
3161       HEAP32[(($51)>>2)]=$49;
3162       __label__ = 9; break;
3163     case 9:
3164       var $53=$3;
3165       var $54=$2;
3166       var $55=(($54+156)|0);
3167       var $56=HEAP32[(($55)>>2)];
3168       var $57=((($56)+(1))|0);
3169       HEAP32[(($55)>>2)]=$57;
3170       var $58=$2;
3171       var $59=(($58+152)|0);
3172       var $60=HEAP32[(($59)>>2)];
3173       var $61=(($60+($56<<2))|0);
3174       HEAP32[(($61)>>2)]=$53;
3175       $1=1;
3176       __label__ = 10; break;
3177     case 10:
3178       var $63=$1;
3179       ;
3180       return $63;
3181     default: assert(0, "bad label: " + __label__);
3182   }
3183 }
3184 _qc_program_localstack_add["X"]=1;
3185
3186 function _qc_program_localstack_append($s, $p, $c) {
3187   ;
3188   var __label__;
3189   __label__ = 2;
3190   while(1) switch(__label__) {
3191     case 2:
3192       var $1;
3193       var $2;
3194       var $3;
3195       var $4;
3196       var $reall;
3197       var $oldalloc;
3198       $2=$s;
3199       $3=$p;
3200       $4=$c;
3201       var $5=$2;
3202       var $6=(($5+156)|0);
3203       var $7=HEAP32[(($6)>>2)];
3204       var $8=$4;
3205       var $9=((($7)+($8))|0);
3206       var $10=$2;
3207       var $11=(($10+160)|0);
3208       var $12=HEAP32[(($11)>>2)];
3209       var $13=(($9)>>>0) > (($12)>>>0);
3210       if ($13) { __label__ = 3; break; } else { __label__ = 14; break; }
3211     case 3:
3212       var $15=$2;
3213       var $16=(($15+160)|0);
3214       var $17=HEAP32[(($16)>>2)];
3215       var $18=(($17)|0)!=0;
3216       if ($18) { __label__ = 8; break; } else { __label__ = 4; break; }
3217     case 4:
3218       var $20=$4;
3219       var $21=(($20)>>>0) < 16;
3220       if ($21) { __label__ = 5; break; } else { __label__ = 6; break; }
3221     case 5:
3222       var $26 = 16;__label__ = 7; break;
3223     case 6:
3224       var $24=$4;
3225       var $26 = $24;__label__ = 7; break;
3226     case 7:
3227       var $26;
3228       var $27=$2;
3229       var $28=(($27+160)|0);
3230       HEAP32[(($28)>>2)]=$26;
3231       var $29=$2;
3232       var $30=(($29+160)|0);
3233       var $31=HEAP32[(($30)>>2)];
3234       var $32=((($31<<2))|0);
3235       var $33=_util_memory_a($32, 44, ((STRING_TABLE.__str)|0));
3236       var $34=$33;
3237       var $35=$2;
3238       var $36=(($35+152)|0);
3239       HEAP32[(($36)>>2)]=$34;
3240       __label__ = 13; break;
3241     case 8:
3242       var $38=$2;
3243       var $39=(($38+160)|0);
3244       var $40=HEAP32[(($39)>>2)];
3245       $oldalloc=$40;
3246       var $41=$2;
3247       var $42=(($41+160)|0);
3248       var $43=HEAP32[(($42)>>2)];
3249       var $44=((($43<<1))|0);
3250       HEAP32[(($42)>>2)]=$44;
3251       var $45=$2;
3252       var $46=(($45+156)|0);
3253       var $47=HEAP32[(($46)>>2)];
3254       var $48=$4;
3255       var $49=((($47)+($48))|0);
3256       var $50=$2;
3257       var $51=(($50+160)|0);
3258       var $52=HEAP32[(($51)>>2)];
3259       var $53=(($49)>>>0) >= (($52)>>>0);
3260       if ($53) { __label__ = 9; break; } else { __label__ = 10; break; }
3261     case 9:
3262       var $55=$2;
3263       var $56=(($55+156)|0);
3264       var $57=HEAP32[(($56)>>2)];
3265       var $58=$4;
3266       var $59=((($57)+($58))|0);
3267       var $60=$2;
3268       var $61=(($60+160)|0);
3269       HEAP32[(($61)>>2)]=$59;
3270       __label__ = 10; break;
3271     case 10:
3272       var $63=$2;
3273       var $64=(($63+160)|0);
3274       var $65=HEAP32[(($64)>>2)];
3275       var $66=((($65<<2))|0);
3276       var $67=_util_memory_a($66, 44, ((STRING_TABLE.__str)|0));
3277       var $68=$67;
3278       $reall=$68;
3279       var $69=$reall;
3280       var $70=(($69)|0)!=0;
3281       if ($70) { __label__ = 12; break; } else { __label__ = 11; break; }
3282     case 11:
3283       var $72=$oldalloc;
3284       var $73=$2;
3285       var $74=(($73+160)|0);
3286       HEAP32[(($74)>>2)]=$72;
3287       $1=0;
3288       __label__ = 15; break;
3289     case 12:
3290       var $76=$reall;
3291       var $77=$76;
3292       var $78=$2;
3293       var $79=(($78+152)|0);
3294       var $80=HEAP32[(($79)>>2)];
3295       var $81=$80;
3296       var $82=$2;
3297       var $83=(($82+156)|0);
3298       var $84=HEAP32[(($83)>>2)];
3299       var $85=((($84<<2))|0);
3300       assert($85 % 1 === 0, 'memcpy given ' + $85 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($77, $81, $85, 4);
3301       var $86=$2;
3302       var $87=(($86+152)|0);
3303       var $88=HEAP32[(($87)>>2)];
3304       var $89=$88;
3305       _util_memory_d($89, 44, ((STRING_TABLE.__str)|0));
3306       var $90=$reall;
3307       var $91=$2;
3308       var $92=(($91+152)|0);
3309       HEAP32[(($92)>>2)]=$90;
3310       __label__ = 13; break;
3311     case 13:
3312       __label__ = 14; break;
3313     case 14:
3314       var $95=$2;
3315       var $96=(($95+156)|0);
3316       var $97=HEAP32[(($96)>>2)];
3317       var $98=$2;
3318       var $99=(($98+152)|0);
3319       var $100=HEAP32[(($99)>>2)];
3320       var $101=(($100+($97<<2))|0);
3321       var $102=$101;
3322       var $103=$3;
3323       var $104=$103;
3324       var $105=$4;
3325       var $106=((($105<<2))|0);
3326       assert($106 % 1 === 0, 'memcpy given ' + $106 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($102, $104, $106, 4);
3327       var $107=$4;
3328       var $108=$2;
3329       var $109=(($108+156)|0);
3330       var $110=HEAP32[(($109)>>2)];
3331       var $111=((($110)+($107))|0);
3332       HEAP32[(($109)>>2)]=$111;
3333       $1=1;
3334       __label__ = 15; break;
3335     case 15:
3336       var $113=$1;
3337       ;
3338       return $113;
3339     default: assert(0, "bad label: " + __label__);
3340   }
3341 }
3342 _qc_program_localstack_append["X"]=1;
3343
3344 function _qc_program_localstack_resize($s, $c) {
3345   ;
3346   var __label__;
3347   __label__ = 2;
3348   while(1) switch(__label__) {
3349     case 2:
3350       var $1;
3351       var $2;
3352       var $3;
3353       var $reall;
3354       $2=$s;
3355       $3=$c;
3356       var $4=$3;
3357       var $5=$2;
3358       var $6=(($5+160)|0);
3359       var $7=HEAP32[(($6)>>2)];
3360       var $8=(($4)>>>0) > (($7)>>>0);
3361       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
3362     case 3:
3363       var $10=$3;
3364       var $11=((($10<<2))|0);
3365       var $12=_util_memory_a($11, 45, ((STRING_TABLE.__str)|0));
3366       var $13=$12;
3367       $reall=$13;
3368       var $14=$reall;
3369       var $15=(($14)|0)!=0;
3370       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3371     case 4:
3372       $1=0;
3373       __label__ = 11; break;
3374     case 5:
3375       var $18=$reall;
3376       var $19=$18;
3377       var $20=$2;
3378       var $21=(($20+152)|0);
3379       var $22=HEAP32[(($21)>>2)];
3380       var $23=$22;
3381       var $24=$2;
3382       var $25=(($24+156)|0);
3383       var $26=HEAP32[(($25)>>2)];
3384       var $27=((($26<<2))|0);
3385       assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4);
3386       var $28=$3;
3387       var $29=$2;
3388       var $30=(($29+160)|0);
3389       HEAP32[(($30)>>2)]=$28;
3390       var $31=$3;
3391       var $32=$2;
3392       var $33=(($32+156)|0);
3393       HEAP32[(($33)>>2)]=$31;
3394       var $34=$2;
3395       var $35=(($34+152)|0);
3396       var $36=HEAP32[(($35)>>2)];
3397       var $37=$36;
3398       _util_memory_d($37, 45, ((STRING_TABLE.__str)|0));
3399       var $38=$reall;
3400       var $39=$2;
3401       var $40=(($39+152)|0);
3402       HEAP32[(($40)>>2)]=$38;
3403       $1=1;
3404       __label__ = 11; break;
3405     case 6:
3406       var $42=$3;
3407       var $43=$2;
3408       var $44=(($43+156)|0);
3409       HEAP32[(($44)>>2)]=$42;
3410       var $45=$3;
3411       var $46=$2;
3412       var $47=(($46+160)|0);
3413       var $48=HEAP32[(($47)>>2)];
3414       var $49=Math.floor(((($48)>>>0))/(2));
3415       var $50=(($45)>>>0) < (($49)>>>0);
3416       if ($50) { __label__ = 7; break; } else { __label__ = 10; break; }
3417     case 7:
3418       var $52=$3;
3419       var $53=((($52<<2))|0);
3420       var $54=_util_memory_a($53, 45, ((STRING_TABLE.__str)|0));
3421       var $55=$54;
3422       $reall=$55;
3423       var $56=$reall;
3424       var $57=(($56)|0)!=0;
3425       if ($57) { __label__ = 9; break; } else { __label__ = 8; break; }
3426     case 8:
3427       $1=0;
3428       __label__ = 11; break;
3429     case 9:
3430       var $60=$reall;
3431       var $61=$60;
3432       var $62=$2;
3433       var $63=(($62+152)|0);
3434       var $64=HEAP32[(($63)>>2)];
3435       var $65=$64;
3436       var $66=$3;
3437       var $67=((($66<<2))|0);
3438       assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4);
3439       var $68=$2;
3440       var $69=(($68+152)|0);
3441       var $70=HEAP32[(($69)>>2)];
3442       var $71=$70;
3443       _util_memory_d($71, 45, ((STRING_TABLE.__str)|0));
3444       var $72=$reall;
3445       var $73=$2;
3446       var $74=(($73+152)|0);
3447       HEAP32[(($74)>>2)]=$72;
3448       var $75=$3;
3449       var $76=$2;
3450       var $77=(($76+160)|0);
3451       HEAP32[(($77)>>2)]=$75;
3452       __label__ = 10; break;
3453     case 10:
3454       $1=1;
3455       __label__ = 11; break;
3456     case 11:
3457       var $80=$1;
3458       ;
3459       return $80;
3460     default: assert(0, "bad label: " + __label__);
3461   }
3462 }
3463 _qc_program_localstack_resize["X"]=1;
3464
3465 function _qc_program_stack_remove($self, $idx) {
3466   ;
3467   var __label__;
3468   __label__ = 2;
3469   while(1) switch(__label__) {
3470     case 2:
3471       var $1;
3472       var $2;
3473       var $3;
3474       var $i;
3475       var $reall;
3476       $2=$self;
3477       $3=$idx;
3478       var $4=$3;
3479       var $5=$2;
3480       var $6=(($5+168)|0);
3481       var $7=HEAP32[(($6)>>2)];
3482       var $8=(($4)>>>0) >= (($7)>>>0);
3483       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
3484     case 3:
3485       $1=1;
3486       __label__ = 13; break;
3487     case 4:
3488       var $11=$3;
3489       $i=$11;
3490       __label__ = 5; break;
3491     case 5:
3492       var $13=$i;
3493       var $14=$2;
3494       var $15=(($14+168)|0);
3495       var $16=HEAP32[(($15)>>2)];
3496       var $17=((($16)-(1))|0);
3497       var $18=(($13)>>>0) < (($17)>>>0);
3498       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3499     case 6:
3500       var $20=$i;
3501       var $21=$2;
3502       var $22=(($21+164)|0);
3503       var $23=HEAP32[(($22)>>2)];
3504       var $24=(($23+($20)*(12))|0);
3505       var $25=$i;
3506       var $26=((($25)+(1))|0);
3507       var $27=$2;
3508       var $28=(($27+164)|0);
3509       var $29=HEAP32[(($28)>>2)];
3510       var $30=(($29+($26)*(12))|0);
3511       var $31=$24;
3512       var $32=$30;
3513       assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($31)>>2)]=HEAP32[(($32)>>2)];HEAP32[((($31)+(4))>>2)]=HEAP32[((($32)+(4))>>2)];HEAP32[((($31)+(8))>>2)]=HEAP32[((($32)+(8))>>2)];
3514       __label__ = 7; break;
3515     case 7:
3516       var $34=$i;
3517       var $35=((($34)+(1))|0);
3518       $i=$35;
3519       __label__ = 5; break;
3520     case 8:
3521       var $37=$2;
3522       var $38=(($37+168)|0);
3523       var $39=HEAP32[(($38)>>2)];
3524       var $40=((($39)-(1))|0);
3525       HEAP32[(($38)>>2)]=$40;
3526       var $41=$2;
3527       var $42=(($41+168)|0);
3528       var $43=HEAP32[(($42)>>2)];
3529       var $44=$2;
3530       var $45=(($44+168)|0);
3531       var $46=HEAP32[(($45)>>2)];
3532       var $47=Math.floor(((($46)>>>0))/(2));
3533       var $48=(($43)>>>0) < (($47)>>>0);
3534       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
3535     case 9:
3536       var $50=$2;
3537       var $51=(($50+172)|0);
3538       var $52=HEAP32[(($51)>>2)];
3539       var $53=Math.floor(((($52)>>>0))/(2));
3540       HEAP32[(($51)>>2)]=$53;
3541       var $54=$2;
3542       var $55=(($54+168)|0);
3543       var $56=HEAP32[(($55)>>2)];
3544       var $57=((($56)*(12))|0);
3545       var $58=_util_memory_a($57, 46, ((STRING_TABLE.__str)|0));
3546       var $59=$58;
3547       $reall=$59;
3548       var $60=$reall;
3549       var $61=(($60)|0)!=0;
3550       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
3551     case 10:
3552       $1=0;
3553       __label__ = 13; break;
3554     case 11:
3555       var $64=$reall;
3556       var $65=$64;
3557       var $66=$2;
3558       var $67=(($66+164)|0);
3559       var $68=HEAP32[(($67)>>2)];
3560       var $69=$68;
3561       var $70=$2;
3562       var $71=(($70+168)|0);
3563       var $72=HEAP32[(($71)>>2)];
3564       var $73=((($72)*(12))|0);
3565       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
3566       var $74=$2;
3567       var $75=(($74+164)|0);
3568       var $76=HEAP32[(($75)>>2)];
3569       var $77=$76;
3570       _util_memory_d($77, 46, ((STRING_TABLE.__str)|0));
3571       var $78=$reall;
3572       var $79=$2;
3573       var $80=(($79+164)|0);
3574       HEAP32[(($80)>>2)]=$78;
3575       __label__ = 12; break;
3576     case 12:
3577       $1=1;
3578       __label__ = 13; break;
3579     case 13:
3580       var $83=$1;
3581       ;
3582       return $83;
3583     default: assert(0, "bad label: " + __label__);
3584   }
3585 }
3586 _qc_program_stack_remove["X"]=1;
3587
3588 function _qc_program_stack_add($self, $f_0, $f_1, $f_2) {
3589   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
3590   var __label__;
3591   __label__ = 2;
3592   while(1) switch(__label__) {
3593     case 2:
3594       var $1;
3595       var $2;
3596       var $f=__stackBase__;
3597       var $reall;
3598       $2=$self;
3599       var $3=(($f)|0);
3600       HEAP32[(($3)>>2)]=$f_0;
3601       var $4=(($f+4)|0);
3602       HEAP32[(($4)>>2)]=$f_1;
3603       var $5=(($f+8)|0);
3604       HEAP32[(($5)>>2)]=$f_2;
3605       var $6=$2;
3606       var $7=(($6+168)|0);
3607       var $8=HEAP32[(($7)>>2)];
3608       var $9=$2;
3609       var $10=(($9+172)|0);
3610       var $11=HEAP32[(($10)>>2)];
3611       var $12=(($8)|0)==(($11)|0);
3612       if ($12) { __label__ = 3; break; } else { __label__ = 9; break; }
3613     case 3:
3614       var $14=$2;
3615       var $15=(($14+172)|0);
3616       var $16=HEAP32[(($15)>>2)];
3617       var $17=(($16)|0)!=0;
3618       if ($17) { __label__ = 5; break; } else { __label__ = 4; break; }
3619     case 4:
3620       var $19=$2;
3621       var $20=(($19+172)|0);
3622       HEAP32[(($20)>>2)]=16;
3623       __label__ = 6; break;
3624     case 5:
3625       var $22=$2;
3626       var $23=(($22+172)|0);
3627       var $24=HEAP32[(($23)>>2)];
3628       var $25=((($24<<1))|0);
3629       HEAP32[(($23)>>2)]=$25;
3630       __label__ = 6; break;
3631     case 6:
3632       var $27=$2;
3633       var $28=(($27+172)|0);
3634       var $29=HEAP32[(($28)>>2)];
3635       var $30=((($29)*(12))|0);
3636       var $31=_util_memory_a($30, 46, ((STRING_TABLE.__str)|0));
3637       var $32=$31;
3638       $reall=$32;
3639       var $33=$reall;
3640       var $34=(($33)|0)!=0;
3641       if ($34) { __label__ = 8; break; } else { __label__ = 7; break; }
3642     case 7:
3643       $1=0;
3644       __label__ = 10; break;
3645     case 8:
3646       var $37=$reall;
3647       var $38=$37;
3648       var $39=$2;
3649       var $40=(($39+164)|0);
3650       var $41=HEAP32[(($40)>>2)];
3651       var $42=$41;
3652       var $43=$2;
3653       var $44=(($43+168)|0);
3654       var $45=HEAP32[(($44)>>2)];
3655       var $46=((($45)*(12))|0);
3656       assert($46 % 1 === 0, 'memcpy given ' + $46 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($38, $42, $46, 4);
3657       var $47=$2;
3658       var $48=(($47+164)|0);
3659       var $49=HEAP32[(($48)>>2)];
3660       var $50=$49;
3661       _util_memory_d($50, 46, ((STRING_TABLE.__str)|0));
3662       var $51=$reall;
3663       var $52=$2;
3664       var $53=(($52+164)|0);
3665       HEAP32[(($53)>>2)]=$51;
3666       __label__ = 9; break;
3667     case 9:
3668       var $55=$2;
3669       var $56=(($55+168)|0);
3670       var $57=HEAP32[(($56)>>2)];
3671       var $58=((($57)+(1))|0);
3672       HEAP32[(($56)>>2)]=$58;
3673       var $59=$2;
3674       var $60=(($59+164)|0);
3675       var $61=HEAP32[(($60)>>2)];
3676       var $62=(($61+($57)*(12))|0);
3677       var $63=$62;
3678       var $64=$f;
3679       assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($63)>>2)]=HEAP32[(($64)>>2)];HEAP32[((($63)+(4))>>2)]=HEAP32[((($64)+(4))>>2)];HEAP32[((($63)+(8))>>2)]=HEAP32[((($64)+(8))>>2)];
3680       $1=1;
3681       __label__ = 10; break;
3682     case 10:
3683       var $66=$1;
3684       STACKTOP = __stackBase__;
3685       return $66;
3686     default: assert(0, "bad label: " + __label__);
3687   }
3688 }
3689 _qc_program_stack_add["X"]=1;
3690
3691 function _qc_program_profile_remove($self, $idx) {
3692   ;
3693   var __label__;
3694   __label__ = 2;
3695   while(1) switch(__label__) {
3696     case 2:
3697       var $1;
3698       var $2;
3699       var $3;
3700       var $i;
3701       var $reall;
3702       $2=$self;
3703       $3=$idx;
3704       var $4=$3;
3705       var $5=$2;
3706       var $6=(($5+120)|0);
3707       var $7=HEAP32[(($6)>>2)];
3708       var $8=(($4)>>>0) >= (($7)>>>0);
3709       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
3710     case 3:
3711       $1=1;
3712       __label__ = 13; break;
3713     case 4:
3714       var $11=$3;
3715       $i=$11;
3716       __label__ = 5; break;
3717     case 5:
3718       var $13=$i;
3719       var $14=$2;
3720       var $15=(($14+120)|0);
3721       var $16=HEAP32[(($15)>>2)];
3722       var $17=((($16)-(1))|0);
3723       var $18=(($13)>>>0) < (($17)>>>0);
3724       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3725     case 6:
3726       var $20=$i;
3727       var $21=((($20)+(1))|0);
3728       var $22=$2;
3729       var $23=(($22+116)|0);
3730       var $24=HEAP32[(($23)>>2)];
3731       var $25=(($24+($21<<2))|0);
3732       var $26=HEAP32[(($25)>>2)];
3733       var $27=$i;
3734       var $28=$2;
3735       var $29=(($28+116)|0);
3736       var $30=HEAP32[(($29)>>2)];
3737       var $31=(($30+($27<<2))|0);
3738       HEAP32[(($31)>>2)]=$26;
3739       __label__ = 7; break;
3740     case 7:
3741       var $33=$i;
3742       var $34=((($33)+(1))|0);
3743       $i=$34;
3744       __label__ = 5; break;
3745     case 8:
3746       var $36=$2;
3747       var $37=(($36+120)|0);
3748       var $38=HEAP32[(($37)>>2)];
3749       var $39=((($38)-(1))|0);
3750       HEAP32[(($37)>>2)]=$39;
3751       var $40=$2;
3752       var $41=(($40+120)|0);
3753       var $42=HEAP32[(($41)>>2)];
3754       var $43=$2;
3755       var $44=(($43+120)|0);
3756       var $45=HEAP32[(($44)>>2)];
3757       var $46=Math.floor(((($45)>>>0))/(2));
3758       var $47=(($42)>>>0) < (($46)>>>0);
3759       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
3760     case 9:
3761       var $49=$2;
3762       var $50=(($49+124)|0);
3763       var $51=HEAP32[(($50)>>2)];
3764       var $52=Math.floor(((($51)>>>0))/(2));
3765       HEAP32[(($50)>>2)]=$52;
3766       var $53=$2;
3767       var $54=(($53+120)|0);
3768       var $55=HEAP32[(($54)>>2)];
3769       var $56=((($55<<2))|0);
3770       var $57=_util_memory_a($56, 48, ((STRING_TABLE.__str)|0));
3771       var $58=$57;
3772       $reall=$58;
3773       var $59=$reall;
3774       var $60=(($59)|0)!=0;
3775       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
3776     case 10:
3777       $1=0;
3778       __label__ = 13; break;
3779     case 11:
3780       var $63=$reall;
3781       var $64=$63;
3782       var $65=$2;
3783       var $66=(($65+116)|0);
3784       var $67=HEAP32[(($66)>>2)];
3785       var $68=$67;
3786       var $69=$2;
3787       var $70=(($69+120)|0);
3788       var $71=HEAP32[(($70)>>2)];
3789       var $72=((($71<<2))|0);
3790       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
3791       var $73=$2;
3792       var $74=(($73+116)|0);
3793       var $75=HEAP32[(($74)>>2)];
3794       var $76=$75;
3795       _util_memory_d($76, 48, ((STRING_TABLE.__str)|0));
3796       var $77=$reall;
3797       var $78=$2;
3798       var $79=(($78+116)|0);
3799       HEAP32[(($79)>>2)]=$77;
3800       __label__ = 12; break;
3801     case 12:
3802       $1=1;
3803       __label__ = 13; break;
3804     case 13:
3805       var $82=$1;
3806       ;
3807       return $82;
3808     default: assert(0, "bad label: " + __label__);
3809   }
3810 }
3811 _qc_program_profile_remove["X"]=1;
3812
3813 function _qc_program_profile_add($self, $f) {
3814   ;
3815   var __label__;
3816   __label__ = 2;
3817   while(1) switch(__label__) {
3818     case 2:
3819       var $1;
3820       var $2;
3821       var $3;
3822       var $reall;
3823       $2=$self;
3824       $3=$f;
3825       var $4=$2;
3826       var $5=(($4+120)|0);
3827       var $6=HEAP32[(($5)>>2)];
3828       var $7=$2;
3829       var $8=(($7+124)|0);
3830       var $9=HEAP32[(($8)>>2)];
3831       var $10=(($6)|0)==(($9)|0);
3832       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
3833     case 3:
3834       var $12=$2;
3835       var $13=(($12+124)|0);
3836       var $14=HEAP32[(($13)>>2)];
3837       var $15=(($14)|0)!=0;
3838       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3839     case 4:
3840       var $17=$2;
3841       var $18=(($17+124)|0);
3842       HEAP32[(($18)>>2)]=16;
3843       __label__ = 6; break;
3844     case 5:
3845       var $20=$2;
3846       var $21=(($20+124)|0);
3847       var $22=HEAP32[(($21)>>2)];
3848       var $23=((($22<<1))|0);
3849       HEAP32[(($21)>>2)]=$23;
3850       __label__ = 6; break;
3851     case 6:
3852       var $25=$2;
3853       var $26=(($25+124)|0);
3854       var $27=HEAP32[(($26)>>2)];
3855       var $28=((($27<<2))|0);
3856       var $29=_util_memory_a($28, 48, ((STRING_TABLE.__str)|0));
3857       var $30=$29;
3858       $reall=$30;
3859       var $31=$reall;
3860       var $32=(($31)|0)!=0;
3861       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
3862     case 7:
3863       $1=0;
3864       __label__ = 10; break;
3865     case 8:
3866       var $35=$reall;
3867       var $36=$35;
3868       var $37=$2;
3869       var $38=(($37+116)|0);
3870       var $39=HEAP32[(($38)>>2)];
3871       var $40=$39;
3872       var $41=$2;
3873       var $42=(($41+120)|0);
3874       var $43=HEAP32[(($42)>>2)];
3875       var $44=((($43<<2))|0);
3876       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
3877       var $45=$2;
3878       var $46=(($45+116)|0);
3879       var $47=HEAP32[(($46)>>2)];
3880       var $48=$47;
3881       _util_memory_d($48, 48, ((STRING_TABLE.__str)|0));
3882       var $49=$reall;
3883       var $50=$2;
3884       var $51=(($50+116)|0);
3885       HEAP32[(($51)>>2)]=$49;
3886       __label__ = 9; break;
3887     case 9:
3888       var $53=$3;
3889       var $54=$2;
3890       var $55=(($54+120)|0);
3891       var $56=HEAP32[(($55)>>2)];
3892       var $57=((($56)+(1))|0);
3893       HEAP32[(($55)>>2)]=$57;
3894       var $58=$2;
3895       var $59=(($58+116)|0);
3896       var $60=HEAP32[(($59)>>2)];
3897       var $61=(($60+($56<<2))|0);
3898       HEAP32[(($61)>>2)]=$53;
3899       $1=1;
3900       __label__ = 10; break;
3901     case 10:
3902       var $63=$1;
3903       ;
3904       return $63;
3905     default: assert(0, "bad label: " + __label__);
3906   }
3907 }
3908 _qc_program_profile_add["X"]=1;
3909
3910 function _qc_program_profile_resize($s, $c) {
3911   ;
3912   var __label__;
3913   __label__ = 2;
3914   while(1) switch(__label__) {
3915     case 2:
3916       var $1;
3917       var $2;
3918       var $3;
3919       var $reall;
3920       $2=$s;
3921       $3=$c;
3922       var $4=$3;
3923       var $5=$2;
3924       var $6=(($5+124)|0);
3925       var $7=HEAP32[(($6)>>2)];
3926       var $8=(($4)>>>0) > (($7)>>>0);
3927       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
3928     case 3:
3929       var $10=$3;
3930       var $11=((($10<<2))|0);
3931       var $12=_util_memory_a($11, 49, ((STRING_TABLE.__str)|0));
3932       var $13=$12;
3933       $reall=$13;
3934       var $14=$reall;
3935       var $15=(($14)|0)!=0;
3936       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3937     case 4:
3938       $1=0;
3939       __label__ = 11; break;
3940     case 5:
3941       var $18=$reall;
3942       var $19=$18;
3943       var $20=$2;
3944       var $21=(($20+116)|0);
3945       var $22=HEAP32[(($21)>>2)];
3946       var $23=$22;
3947       var $24=$2;
3948       var $25=(($24+120)|0);
3949       var $26=HEAP32[(($25)>>2)];
3950       var $27=((($26<<2))|0);
3951       assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4);
3952       var $28=$3;
3953       var $29=$2;
3954       var $30=(($29+124)|0);
3955       HEAP32[(($30)>>2)]=$28;
3956       var $31=$3;
3957       var $32=$2;
3958       var $33=(($32+120)|0);
3959       HEAP32[(($33)>>2)]=$31;
3960       var $34=$2;
3961       var $35=(($34+116)|0);
3962       var $36=HEAP32[(($35)>>2)];
3963       var $37=$36;
3964       _util_memory_d($37, 49, ((STRING_TABLE.__str)|0));
3965       var $38=$reall;
3966       var $39=$2;
3967       var $40=(($39+116)|0);
3968       HEAP32[(($40)>>2)]=$38;
3969       $1=1;
3970       __label__ = 11; break;
3971     case 6:
3972       var $42=$3;
3973       var $43=$2;
3974       var $44=(($43+120)|0);
3975       HEAP32[(($44)>>2)]=$42;
3976       var $45=$3;
3977       var $46=$2;
3978       var $47=(($46+124)|0);
3979       var $48=HEAP32[(($47)>>2)];
3980       var $49=Math.floor(((($48)>>>0))/(2));
3981       var $50=(($45)>>>0) < (($49)>>>0);
3982       if ($50) { __label__ = 7; break; } else { __label__ = 10; break; }
3983     case 7:
3984       var $52=$3;
3985       var $53=((($52<<2))|0);
3986       var $54=_util_memory_a($53, 49, ((STRING_TABLE.__str)|0));
3987       var $55=$54;
3988       $reall=$55;
3989       var $56=$reall;
3990       var $57=(($56)|0)!=0;
3991       if ($57) { __label__ = 9; break; } else { __label__ = 8; break; }
3992     case 8:
3993       $1=0;
3994       __label__ = 11; break;
3995     case 9:
3996       var $60=$reall;
3997       var $61=$60;
3998       var $62=$2;
3999       var $63=(($62+116)|0);
4000       var $64=HEAP32[(($63)>>2)];
4001       var $65=$64;
4002       var $66=$3;
4003       var $67=((($66<<2))|0);
4004       assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4);
4005       var $68=$2;
4006       var $69=(($68+116)|0);
4007       var $70=HEAP32[(($69)>>2)];
4008       var $71=$70;
4009       _util_memory_d($71, 49, ((STRING_TABLE.__str)|0));
4010       var $72=$reall;
4011       var $73=$2;
4012       var $74=(($73+116)|0);
4013       HEAP32[(($74)>>2)]=$72;
4014       var $75=$3;
4015       var $76=$2;
4016       var $77=(($76+124)|0);
4017       HEAP32[(($77)>>2)]=$75;
4018       __label__ = 10; break;
4019     case 10:
4020       $1=1;
4021       __label__ = 11; break;
4022     case 11:
4023       var $80=$1;
4024       ;
4025       return $80;
4026     default: assert(0, "bad label: " + __label__);
4027   }
4028 }
4029 _qc_program_profile_resize["X"]=1;
4030
4031 function _qc_program_builtins_remove($self, $idx) {
4032   ;
4033   var __label__;
4034   __label__ = 2;
4035   while(1) switch(__label__) {
4036     case 2:
4037       var $1;
4038       var $2;
4039       var $3;
4040       var $i;
4041       var $reall;
4042       $2=$self;
4043       $3=$idx;
4044       var $4=$3;
4045       var $5=$2;
4046       var $6=(($5+132)|0);
4047       var $7=HEAP32[(($6)>>2)];
4048       var $8=(($4)>>>0) >= (($7)>>>0);
4049       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
4050     case 3:
4051       $1=1;
4052       __label__ = 13; break;
4053     case 4:
4054       var $11=$3;
4055       $i=$11;
4056       __label__ = 5; break;
4057     case 5:
4058       var $13=$i;
4059       var $14=$2;
4060       var $15=(($14+132)|0);
4061       var $16=HEAP32[(($15)>>2)];
4062       var $17=((($16)-(1))|0);
4063       var $18=(($13)>>>0) < (($17)>>>0);
4064       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
4065     case 6:
4066       var $20=$i;
4067       var $21=((($20)+(1))|0);
4068       var $22=$2;
4069       var $23=(($22+128)|0);
4070       var $24=HEAP32[(($23)>>2)];
4071       var $25=(($24+($21<<2))|0);
4072       var $26=HEAP32[(($25)>>2)];
4073       var $27=$i;
4074       var $28=$2;
4075       var $29=(($28+128)|0);
4076       var $30=HEAP32[(($29)>>2)];
4077       var $31=(($30+($27<<2))|0);
4078       HEAP32[(($31)>>2)]=$26;
4079       __label__ = 7; break;
4080     case 7:
4081       var $33=$i;
4082       var $34=((($33)+(1))|0);
4083       $i=$34;
4084       __label__ = 5; break;
4085     case 8:
4086       var $36=$2;
4087       var $37=(($36+132)|0);
4088       var $38=HEAP32[(($37)>>2)];
4089       var $39=((($38)-(1))|0);
4090       HEAP32[(($37)>>2)]=$39;
4091       var $40=$2;
4092       var $41=(($40+132)|0);
4093       var $42=HEAP32[(($41)>>2)];
4094       var $43=$2;
4095       var $44=(($43+132)|0);
4096       var $45=HEAP32[(($44)>>2)];
4097       var $46=Math.floor(((($45)>>>0))/(2));
4098       var $47=(($42)>>>0) < (($46)>>>0);
4099       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
4100     case 9:
4101       var $49=$2;
4102       var $50=(($49+136)|0);
4103       var $51=HEAP32[(($50)>>2)];
4104       var $52=Math.floor(((($51)>>>0))/(2));
4105       HEAP32[(($50)>>2)]=$52;
4106       var $53=$2;
4107       var $54=(($53+132)|0);
4108       var $55=HEAP32[(($54)>>2)];
4109       var $56=((($55<<2))|0);
4110       var $57=_util_memory_a($56, 51, ((STRING_TABLE.__str)|0));
4111       var $58=$57;
4112       $reall=$58;
4113       var $59=$reall;
4114       var $60=(($59)|0)!=0;
4115       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
4116     case 10:
4117       $1=0;
4118       __label__ = 13; break;
4119     case 11:
4120       var $63=$reall;
4121       var $64=$63;
4122       var $65=$2;
4123       var $66=(($65+128)|0);
4124       var $67=HEAP32[(($66)>>2)];
4125       var $68=$67;
4126       var $69=$2;
4127       var $70=(($69+132)|0);
4128       var $71=HEAP32[(($70)>>2)];
4129       var $72=((($71<<2))|0);
4130       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
4131       var $73=$2;
4132       var $74=(($73+128)|0);
4133       var $75=HEAP32[(($74)>>2)];
4134       var $76=$75;
4135       _util_memory_d($76, 51, ((STRING_TABLE.__str)|0));
4136       var $77=$reall;
4137       var $78=$2;
4138       var $79=(($78+128)|0);
4139       HEAP32[(($79)>>2)]=$77;
4140       __label__ = 12; break;
4141     case 12:
4142       $1=1;
4143       __label__ = 13; break;
4144     case 13:
4145       var $82=$1;
4146       ;
4147       return $82;
4148     default: assert(0, "bad label: " + __label__);
4149   }
4150 }
4151 _qc_program_builtins_remove["X"]=1;
4152
4153 function _qc_program_builtins_add($self, $f) {
4154   ;
4155   var __label__;
4156   __label__ = 2;
4157   while(1) switch(__label__) {
4158     case 2:
4159       var $1;
4160       var $2;
4161       var $3;
4162       var $reall;
4163       $2=$self;
4164       $3=$f;
4165       var $4=$2;
4166       var $5=(($4+132)|0);
4167       var $6=HEAP32[(($5)>>2)];
4168       var $7=$2;
4169       var $8=(($7+136)|0);
4170       var $9=HEAP32[(($8)>>2)];
4171       var $10=(($6)|0)==(($9)|0);
4172       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
4173     case 3:
4174       var $12=$2;
4175       var $13=(($12+136)|0);
4176       var $14=HEAP32[(($13)>>2)];
4177       var $15=(($14)|0)!=0;
4178       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
4179     case 4:
4180       var $17=$2;
4181       var $18=(($17+136)|0);
4182       HEAP32[(($18)>>2)]=16;
4183       __label__ = 6; break;
4184     case 5:
4185       var $20=$2;
4186       var $21=(($20+136)|0);
4187       var $22=HEAP32[(($21)>>2)];
4188       var $23=((($22<<1))|0);
4189       HEAP32[(($21)>>2)]=$23;
4190       __label__ = 6; break;
4191     case 6:
4192       var $25=$2;
4193       var $26=(($25+136)|0);
4194       var $27=HEAP32[(($26)>>2)];
4195       var $28=((($27<<2))|0);
4196       var $29=_util_memory_a($28, 51, ((STRING_TABLE.__str)|0));
4197       var $30=$29;
4198       $reall=$30;
4199       var $31=$reall;
4200       var $32=(($31)|0)!=0;
4201       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
4202     case 7:
4203       $1=0;
4204       __label__ = 10; break;
4205     case 8:
4206       var $35=$reall;
4207       var $36=$35;
4208       var $37=$2;
4209       var $38=(($37+128)|0);
4210       var $39=HEAP32[(($38)>>2)];
4211       var $40=$39;
4212       var $41=$2;
4213       var $42=(($41+132)|0);
4214       var $43=HEAP32[(($42)>>2)];
4215       var $44=((($43<<2))|0);
4216       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
4217       var $45=$2;
4218       var $46=(($45+128)|0);
4219       var $47=HEAP32[(($46)>>2)];
4220       var $48=$47;
4221       _util_memory_d($48, 51, ((STRING_TABLE.__str)|0));
4222       var $49=$reall;
4223       var $50=$2;
4224       var $51=(($50+128)|0);
4225       HEAP32[(($51)>>2)]=$49;
4226       __label__ = 9; break;
4227     case 9:
4228       var $53=$3;
4229       var $54=$2;
4230       var $55=(($54+132)|0);
4231       var $56=HEAP32[(($55)>>2)];
4232       var $57=((($56)+(1))|0);
4233       HEAP32[(($55)>>2)]=$57;
4234       var $58=$2;
4235       var $59=(($58+128)|0);
4236       var $60=HEAP32[(($59)>>2)];
4237       var $61=(($60+($56<<2))|0);
4238       HEAP32[(($61)>>2)]=$53;
4239       $1=1;
4240       __label__ = 10; break;
4241     case 10:
4242       var $63=$1;
4243       ;
4244       return $63;
4245     default: assert(0, "bad label: " + __label__);
4246   }
4247 }
4248 _qc_program_builtins_add["X"]=1;
4249
4250 function _prog_load($filename) {
4251   var __stackBase__  = STACKTOP; STACKTOP += 60; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
4252   var __label__;
4253   __label__ = 2;
4254   while(1) switch(__label__) {
4255     case 2:
4256       var $1;
4257       var $2;
4258       var $prog;
4259       var $header=__stackBase__;
4260       var $i;
4261       var $file;
4262       $2=$filename;
4263       var $3=$2;
4264       var $4=_util_fopen($3, ((STRING_TABLE.__str1)|0));
4265       $file=$4;
4266       var $5=$file;
4267       var $6=(($5)|0)!=0;
4268       if ($6) { __label__ = 4; break; } else { __label__ = 3; break; }
4269     case 3:
4270       $1=0;
4271       __label__ = 80; break;
4272     case 4:
4273       var $9=$header;
4274       var $10=$file;
4275       var $11=_fread($9, 60, 1, $10);
4276       var $12=(($11)|0)!=1;
4277       if ($12) { __label__ = 5; break; } else { __label__ = 6; break; }
4278     case 5:
4279       var $14=$2;
4280       _loaderror(((STRING_TABLE.__str2)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$14,tempInt));
4281       var $15=$file;
4282       var $16=_fclose($15);
4283       $1=0;
4284       __label__ = 80; break;
4285     case 6:
4286       var $18=(($header)|0);
4287       var $19=HEAP32[(($18)>>2)];
4288       var $20=(($19)|0)!=6;
4289       if ($20) { __label__ = 7; break; } else { __label__ = 8; break; }
4290     case 7:
4291       var $22=(($header)|0);
4292       var $23=HEAP32[(($22)>>2)];
4293       _loaderror(((STRING_TABLE.__str3)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$23,tempInt));
4294       var $24=$file;
4295       var $25=_fclose($24);
4296       $1=0;
4297       __label__ = 80; break;
4298     case 8:
4299       var $27=_util_memory_a(188, 98, ((STRING_TABLE.__str)|0));
4300       var $28=$27;
4301       $prog=$28;
4302       var $29=$prog;
4303       var $30=(($29)|0)!=0;
4304       if ($30) { __label__ = 10; break; } else { __label__ = 9; break; }
4305     case 9:
4306       var $32=$file;
4307       var $33=_fclose($32);
4308       var $34=_printf(((STRING_TABLE.__str4)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4309       $1=0;
4310       __label__ = 80; break;
4311     case 10:
4312       var $36=$prog;
4313       var $37=$36;
4314       for (var $$dest = $37>>2, $$stop = $$dest + 47; $$dest < $$stop; $$dest++) {
4315         HEAP32[$$dest] = 0
4316       };
4317       var $38=(($header+56)|0);
4318       var $39=HEAP32[(($38)>>2)];
4319       var $40=$prog;
4320       var $41=(($40+144)|0);
4321       HEAP32[(($41)>>2)]=$39;
4322       var $42=(($header+4)|0);
4323       var $43=HEAP16[(($42)>>1)];
4324       var $44=$prog;
4325       var $45=(($44+100)|0);
4326       HEAP16[(($45)>>1)]=$43;
4327       var $46=$2;
4328       var $47=_util_strdup($46);
4329       var $48=$prog;
4330       var $49=(($48)|0);
4331       HEAP32[(($49)>>2)]=$47;
4332       var $50=$prog;
4333       var $51=(($50)|0);
4334       var $52=HEAP32[(($51)>>2)];
4335       var $53=(($52)|0)!=0;
4336       if ($53) { __label__ = 12; break; } else { __label__ = 11; break; }
4337     case 11:
4338       _loaderror(((STRING_TABLE.__str5)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4339       __label__ = 61; break;
4340     case 12:
4341       var $56=$file;
4342       var $57=(($header+8)|0);
4343       var $58=(($57)|0);
4344       var $59=HEAP32[(($58)>>2)];
4345       var $60=_fseek($56, $59, 0);
4346       var $61=(($60)|0)!=0;
4347       if ($61) { __label__ = 13; break; } else { __label__ = 14; break; }
4348     case 13:
4349       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4350       __label__ = 61; break;
4351     case 14:
4352       var $64=(($header+8)|0);
4353       var $65=(($64+4)|0);
4354       var $66=HEAP32[(($65)>>2)];
4355       var $67=$prog;
4356       var $68=(($67+12)|0);
4357       HEAP32[(($68)>>2)]=$66;
4358       var $69=(($header+8)|0);
4359       var $70=(($69+4)|0);
4360       var $71=HEAP32[(($70)>>2)];
4361       var $72=$prog;
4362       var $73=(($72+8)|0);
4363       HEAP32[(($73)>>2)]=$71;
4364       var $74=(($header+8)|0);
4365       var $75=(($74+4)|0);
4366       var $76=HEAP32[(($75)>>2)];
4367       var $77=((($76<<3))|0);
4368       var $78=_util_memory_a($77, 132, ((STRING_TABLE.__str)|0));
4369       var $79=$78;
4370       var $80=$prog;
4371       var $81=(($80+4)|0);
4372       HEAP32[(($81)>>2)]=$79;
4373       var $82=$prog;
4374       var $83=(($82+4)|0);
4375       var $84=HEAP32[(($83)>>2)];
4376       var $85=(($84)|0)!=0;
4377       if ($85) { __label__ = 16; break; } else { __label__ = 15; break; }
4378     case 15:
4379       __label__ = 61; break;
4380     case 16:
4381       var $88=$prog;
4382       var $89=(($88+4)|0);
4383       var $90=HEAP32[(($89)>>2)];
4384       var $91=$90;
4385       var $92=(($header+8)|0);
4386       var $93=(($92+4)|0);
4387       var $94=HEAP32[(($93)>>2)];
4388       var $95=$file;
4389       var $96=_fread($91, 8, $94, $95);
4390       var $97=(($header+8)|0);
4391       var $98=(($97+4)|0);
4392       var $99=HEAP32[(($98)>>2)];
4393       var $100=(($96)|0)!=(($99)|0);
4394       if ($100) { __label__ = 17; break; } else { __label__ = 18; break; }
4395     case 17:
4396       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4397       __label__ = 61; break;
4398     case 18:
4399       var $103=$file;
4400       var $104=(($header+16)|0);
4401       var $105=(($104)|0);
4402       var $106=HEAP32[(($105)>>2)];
4403       var $107=_fseek($103, $106, 0);
4404       var $108=(($107)|0)!=0;
4405       if ($108) { __label__ = 19; break; } else { __label__ = 20; break; }
4406     case 19:
4407       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4408       __label__ = 61; break;
4409     case 20:
4410       var $111=(($header+16)|0);
4411       var $112=(($111+4)|0);
4412       var $113=HEAP32[(($112)>>2)];
4413       var $114=$prog;
4414       var $115=(($114+24)|0);
4415       HEAP32[(($115)>>2)]=$113;
4416       var $116=(($header+16)|0);
4417       var $117=(($116+4)|0);
4418       var $118=HEAP32[(($117)>>2)];
4419       var $119=$prog;
4420       var $120=(($119+20)|0);
4421       HEAP32[(($120)>>2)]=$118;
4422       var $121=(($header+16)|0);
4423       var $122=(($121+4)|0);
4424       var $123=HEAP32[(($122)>>2)];
4425       var $124=((($123<<3))|0);
4426       var $125=_util_memory_a($124, 133, ((STRING_TABLE.__str)|0));
4427       var $126=$125;
4428       var $127=$prog;
4429       var $128=(($127+16)|0);
4430       HEAP32[(($128)>>2)]=$126;
4431       var $129=$prog;
4432       var $130=(($129+16)|0);
4433       var $131=HEAP32[(($130)>>2)];
4434       var $132=(($131)|0)!=0;
4435       if ($132) { __label__ = 22; break; } else { __label__ = 21; break; }
4436     case 21:
4437       __label__ = 61; break;
4438     case 22:
4439       var $135=$prog;
4440       var $136=(($135+16)|0);
4441       var $137=HEAP32[(($136)>>2)];
4442       var $138=$137;
4443       var $139=(($header+16)|0);
4444       var $140=(($139+4)|0);
4445       var $141=HEAP32[(($140)>>2)];
4446       var $142=$file;
4447       var $143=_fread($138, 8, $141, $142);
4448       var $144=(($header+16)|0);
4449       var $145=(($144+4)|0);
4450       var $146=HEAP32[(($145)>>2)];
4451       var $147=(($143)|0)!=(($146)|0);
4452       if ($147) { __label__ = 23; break; } else { __label__ = 24; break; }
4453     case 23:
4454       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4455       __label__ = 61; break;
4456     case 24:
4457       var $150=$file;
4458       var $151=(($header+24)|0);
4459       var $152=(($151)|0);
4460       var $153=HEAP32[(($152)>>2)];
4461       var $154=_fseek($150, $153, 0);
4462       var $155=(($154)|0)!=0;
4463       if ($155) { __label__ = 25; break; } else { __label__ = 26; break; }
4464     case 25:
4465       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4466       __label__ = 61; break;
4467     case 26:
4468       var $158=(($header+24)|0);
4469       var $159=(($158+4)|0);
4470       var $160=HEAP32[(($159)>>2)];
4471       var $161=$prog;
4472       var $162=(($161+36)|0);
4473       HEAP32[(($162)>>2)]=$160;
4474       var $163=(($header+24)|0);
4475       var $164=(($163+4)|0);
4476       var $165=HEAP32[(($164)>>2)];
4477       var $166=$prog;
4478       var $167=(($166+32)|0);
4479       HEAP32[(($167)>>2)]=$165;
4480       var $168=(($header+24)|0);
4481       var $169=(($168+4)|0);
4482       var $170=HEAP32[(($169)>>2)];
4483       var $171=((($170<<3))|0);
4484       var $172=_util_memory_a($171, 134, ((STRING_TABLE.__str)|0));
4485       var $173=$172;
4486       var $174=$prog;
4487       var $175=(($174+28)|0);
4488       HEAP32[(($175)>>2)]=$173;
4489       var $176=$prog;
4490       var $177=(($176+28)|0);
4491       var $178=HEAP32[(($177)>>2)];
4492       var $179=(($178)|0)!=0;
4493       if ($179) { __label__ = 28; break; } else { __label__ = 27; break; }
4494     case 27:
4495       __label__ = 61; break;
4496     case 28:
4497       var $182=$prog;
4498       var $183=(($182+28)|0);
4499       var $184=HEAP32[(($183)>>2)];
4500       var $185=$184;
4501       var $186=(($header+24)|0);
4502       var $187=(($186+4)|0);
4503       var $188=HEAP32[(($187)>>2)];
4504       var $189=$file;
4505       var $190=_fread($185, 8, $188, $189);
4506       var $191=(($header+24)|0);
4507       var $192=(($191+4)|0);
4508       var $193=HEAP32[(($192)>>2)];
4509       var $194=(($190)|0)!=(($193)|0);
4510       if ($194) { __label__ = 29; break; } else { __label__ = 30; break; }
4511     case 29:
4512       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4513       __label__ = 61; break;
4514     case 30:
4515       var $197=$file;
4516       var $198=(($header+32)|0);
4517       var $199=(($198)|0);
4518       var $200=HEAP32[(($199)>>2)];
4519       var $201=_fseek($197, $200, 0);
4520       var $202=(($201)|0)!=0;
4521       if ($202) { __label__ = 31; break; } else { __label__ = 32; break; }
4522     case 31:
4523       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4524       __label__ = 61; break;
4525     case 32:
4526       var $205=(($header+32)|0);
4527       var $206=(($205+4)|0);
4528       var $207=HEAP32[(($206)>>2)];
4529       var $208=$prog;
4530       var $209=(($208+48)|0);
4531       HEAP32[(($209)>>2)]=$207;
4532       var $210=(($header+32)|0);
4533       var $211=(($210+4)|0);
4534       var $212=HEAP32[(($211)>>2)];
4535       var $213=$prog;
4536       var $214=(($213+44)|0);
4537       HEAP32[(($214)>>2)]=$212;
4538       var $215=(($header+32)|0);
4539       var $216=(($215+4)|0);
4540       var $217=HEAP32[(($216)>>2)];
4541       var $218=((($217)*(36))|0);
4542       var $219=_util_memory_a($218, 135, ((STRING_TABLE.__str)|0));
4543       var $220=$219;
4544       var $221=$prog;
4545       var $222=(($221+40)|0);
4546       HEAP32[(($222)>>2)]=$220;
4547       var $223=$prog;
4548       var $224=(($223+40)|0);
4549       var $225=HEAP32[(($224)>>2)];
4550       var $226=(($225)|0)!=0;
4551       if ($226) { __label__ = 34; break; } else { __label__ = 33; break; }
4552     case 33:
4553       __label__ = 61; break;
4554     case 34:
4555       var $229=$prog;
4556       var $230=(($229+40)|0);
4557       var $231=HEAP32[(($230)>>2)];
4558       var $232=$231;
4559       var $233=(($header+32)|0);
4560       var $234=(($233+4)|0);
4561       var $235=HEAP32[(($234)>>2)];
4562       var $236=$file;
4563       var $237=_fread($232, 36, $235, $236);
4564       var $238=(($header+32)|0);
4565       var $239=(($238+4)|0);
4566       var $240=HEAP32[(($239)>>2)];
4567       var $241=(($237)|0)!=(($240)|0);
4568       if ($241) { __label__ = 35; break; } else { __label__ = 36; break; }
4569     case 35:
4570       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4571       __label__ = 61; break;
4572     case 36:
4573       var $244=$file;
4574       var $245=(($header+40)|0);
4575       var $246=(($245)|0);
4576       var $247=HEAP32[(($246)>>2)];
4577       var $248=_fseek($244, $247, 0);
4578       var $249=(($248)|0)!=0;
4579       if ($249) { __label__ = 37; break; } else { __label__ = 38; break; }
4580     case 37:
4581       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4582       __label__ = 61; break;
4583     case 38:
4584       var $252=(($header+40)|0);
4585       var $253=(($252+4)|0);
4586       var $254=HEAP32[(($253)>>2)];
4587       var $255=$prog;
4588       var $256=(($255+60)|0);
4589       HEAP32[(($256)>>2)]=$254;
4590       var $257=(($header+40)|0);
4591       var $258=(($257+4)|0);
4592       var $259=HEAP32[(($258)>>2)];
4593       var $260=$prog;
4594       var $261=(($260+56)|0);
4595       HEAP32[(($261)>>2)]=$259;
4596       var $262=(($header+40)|0);
4597       var $263=(($262+4)|0);
4598       var $264=HEAP32[(($263)>>2)];
4599       var $265=(($264)|0);
4600       var $266=_util_memory_a($265, 136, ((STRING_TABLE.__str)|0));
4601       var $267=$prog;
4602       var $268=(($267+52)|0);
4603       HEAP32[(($268)>>2)]=$266;
4604       var $269=$prog;
4605       var $270=(($269+52)|0);
4606       var $271=HEAP32[(($270)>>2)];
4607       var $272=(($271)|0)!=0;
4608       if ($272) { __label__ = 40; break; } else { __label__ = 39; break; }
4609     case 39:
4610       __label__ = 61; break;
4611     case 40:
4612       var $275=$prog;
4613       var $276=(($275+52)|0);
4614       var $277=HEAP32[(($276)>>2)];
4615       var $278=(($header+40)|0);
4616       var $279=(($278+4)|0);
4617       var $280=HEAP32[(($279)>>2)];
4618       var $281=$file;
4619       var $282=_fread($277, 1, $280, $281);
4620       var $283=(($header+40)|0);
4621       var $284=(($283+4)|0);
4622       var $285=HEAP32[(($284)>>2)];
4623       var $286=(($282)|0)!=(($285)|0);
4624       if ($286) { __label__ = 41; break; } else { __label__ = 42; break; }
4625     case 41:
4626       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4627       __label__ = 61; break;
4628     case 42:
4629       var $289=$file;
4630       var $290=(($header+48)|0);
4631       var $291=(($290)|0);
4632       var $292=HEAP32[(($291)>>2)];
4633       var $293=_fseek($289, $292, 0);
4634       var $294=(($293)|0)!=0;
4635       if ($294) { __label__ = 43; break; } else { __label__ = 44; break; }
4636     case 43:
4637       _loaderror(((STRING_TABLE.__str6)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4638       __label__ = 61; break;
4639     case 44:
4640       var $297=(($header+48)|0);
4641       var $298=(($297+4)|0);
4642       var $299=HEAP32[(($298)>>2)];
4643       var $300=$prog;
4644       var $301=(($300+72)|0);
4645       HEAP32[(($301)>>2)]=$299;
4646       var $302=(($header+48)|0);
4647       var $303=(($302+4)|0);
4648       var $304=HEAP32[(($303)>>2)];
4649       var $305=$prog;
4650       var $306=(($305+68)|0);
4651       HEAP32[(($306)>>2)]=$304;
4652       var $307=(($header+48)|0);
4653       var $308=(($307+4)|0);
4654       var $309=HEAP32[(($308)>>2)];
4655       var $310=((($309<<2))|0);
4656       var $311=_util_memory_a($310, 137, ((STRING_TABLE.__str)|0));
4657       var $312=$311;
4658       var $313=$prog;
4659       var $314=(($313+64)|0);
4660       HEAP32[(($314)>>2)]=$312;
4661       var $315=$prog;
4662       var $316=(($315+64)|0);
4663       var $317=HEAP32[(($316)>>2)];
4664       var $318=(($317)|0)!=0;
4665       if ($318) { __label__ = 46; break; } else { __label__ = 45; break; }
4666     case 45:
4667       __label__ = 61; break;
4668     case 46:
4669       var $321=$prog;
4670       var $322=(($321+64)|0);
4671       var $323=HEAP32[(($322)>>2)];
4672       var $324=$323;
4673       var $325=(($header+48)|0);
4674       var $326=(($325+4)|0);
4675       var $327=HEAP32[(($326)>>2)];
4676       var $328=$file;
4677       var $329=_fread($324, 4, $327, $328);
4678       var $330=(($header+48)|0);
4679       var $331=(($330+4)|0);
4680       var $332=HEAP32[(($331)>>2)];
4681       var $333=(($329)|0)!=(($332)|0);
4682       if ($333) { __label__ = 47; break; } else { __label__ = 48; break; }
4683     case 47:
4684       _loaderror(((STRING_TABLE.__str7)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4685       __label__ = 61; break;
4686     case 48:
4687       var $336=$file;
4688       var $337=_fclose($336);
4689       var $338=$prog;
4690       var $339=$prog;
4691       var $340=(($339+8)|0);
4692       var $341=HEAP32[(($340)>>2)];
4693       var $342=_qc_program_profile_resize($338, $341);
4694       if ($342) { __label__ = 50; break; } else { __label__ = 49; break; }
4695     case 49:
4696       __label__ = 61; break;
4697     case 50:
4698       var $345=$prog;
4699       var $346=(($345+56)|0);
4700       var $347=HEAP32[(($346)>>2)];
4701       var $348=$prog;
4702       var $349=(($348+104)|0);
4703       HEAP32[(($349)>>2)]=$347;
4704       var $350=$prog;
4705       var $351=(($350+56)|0);
4706       var $352=HEAP32[(($351)>>2)];
4707       var $353=$prog;
4708       var $354=(($353+108)|0);
4709       HEAP32[(($354)>>2)]=$352;
4710       var $355=$prog;
4711       var $356=$prog;
4712       var $357=(($356+56)|0);
4713       var $358=HEAP32[(($357)>>2)];
4714       var $359=((($358)+(16384))|0);
4715       var $360=_qc_program_strings_resize($355, $359);
4716       if ($360) { __label__ = 52; break; } else { __label__ = 51; break; }
4717     case 51:
4718       __label__ = 61; break;
4719     case 52:
4720       var $363=$prog;
4721       var $364=_qc_program_entitypool_add($363, 1);
4722       if ($364) { __label__ = 54; break; } else { __label__ = 53; break; }
4723     case 53:
4724       _loaderror(((STRING_TABLE.__str8)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4725       __label__ = 61; break;
4726     case 54:
4727       $i=0;
4728       __label__ = 55; break;
4729     case 55:
4730       var $368=$i;
4731       var $369=$prog;
4732       var $370=(($369+144)|0);
4733       var $371=HEAP32[(($370)>>2)];
4734       var $372=(($368)>>>0) < (($371)>>>0);
4735       if ($372) { __label__ = 56; break; } else { __label__ = 60; break; }
4736     case 56:
4737       var $374=$prog;
4738       var $375=_qc_program_entitydata_add($374, 0);
4739       if ($375) { __label__ = 58; break; } else { __label__ = 57; break; }
4740     case 57:
4741       _loaderror(((STRING_TABLE.__str9)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
4742       __label__ = 61; break;
4743     case 58:
4744       __label__ = 59; break;
4745     case 59:
4746       var $379=$i;
4747       var $380=((($379)+(1))|0);
4748       $i=$380;
4749       __label__ = 55; break;
4750     case 60:
4751       var $382=$prog;
4752       var $383=(($382+140)|0);
4753       HEAP32[(($383)>>2)]=1;
4754       var $384=$prog;
4755       $1=$384;
4756       __label__ = 80; break;
4757     case 61:
4758       var $386=$prog;
4759       var $387=(($386)|0);
4760       var $388=HEAP32[(($387)>>2)];
4761       var $389=(($388)|0)!=0;
4762       if ($389) { __label__ = 62; break; } else { __label__ = 63; break; }
4763     case 62:
4764       var $391=$prog;
4765       var $392=(($391)|0);
4766       var $393=HEAP32[(($392)>>2)];
4767       _util_memory_d($393, 167, ((STRING_TABLE.__str)|0));
4768       __label__ = 63; break;
4769     case 63:
4770       var $395=$prog;
4771       var $396=(($395+4)|0);
4772       var $397=HEAP32[(($396)>>2)];
4773       var $398=(($397)|0)!=0;
4774       if ($398) { __label__ = 64; break; } else { __label__ = 65; break; }
4775     case 64:
4776       var $400=$prog;
4777       var $401=(($400+4)|0);
4778       var $402=HEAP32[(($401)>>2)];
4779       var $403=$402;
4780       _util_memory_d($403, 168, ((STRING_TABLE.__str)|0));
4781       __label__ = 65; break;
4782     case 65:
4783       var $405=$prog;
4784       var $406=(($405+16)|0);
4785       var $407=HEAP32[(($406)>>2)];
4786       var $408=(($407)|0)!=0;
4787       if ($408) { __label__ = 66; break; } else { __label__ = 67; break; }
4788     case 66:
4789       var $410=$prog;
4790       var $411=(($410+16)|0);
4791       var $412=HEAP32[(($411)>>2)];
4792       var $413=$412;
4793       _util_memory_d($413, 169, ((STRING_TABLE.__str)|0));
4794       __label__ = 67; break;
4795     case 67:
4796       var $415=$prog;
4797       var $416=(($415+28)|0);
4798       var $417=HEAP32[(($416)>>2)];
4799       var $418=(($417)|0)!=0;
4800       if ($418) { __label__ = 68; break; } else { __label__ = 69; break; }
4801     case 68:
4802       var $420=$prog;
4803       var $421=(($420+28)|0);
4804       var $422=HEAP32[(($421)>>2)];
4805       var $423=$422;
4806       _util_memory_d($423, 170, ((STRING_TABLE.__str)|0));
4807       __label__ = 69; break;
4808     case 69:
4809       var $425=$prog;
4810       var $426=(($425+40)|0);
4811       var $427=HEAP32[(($426)>>2)];
4812       var $428=(($427)|0)!=0;
4813       if ($428) { __label__ = 70; break; } else { __label__ = 71; break; }
4814     case 70:
4815       var $430=$prog;
4816       var $431=(($430+40)|0);
4817       var $432=HEAP32[(($431)>>2)];
4818       var $433=$432;
4819       _util_memory_d($433, 171, ((STRING_TABLE.__str)|0));
4820       __label__ = 71; break;
4821     case 71:
4822       var $435=$prog;
4823       var $436=(($435+52)|0);
4824       var $437=HEAP32[(($436)>>2)];
4825       var $438=(($437)|0)!=0;
4826       if ($438) { __label__ = 72; break; } else { __label__ = 73; break; }
4827     case 72:
4828       var $440=$prog;
4829       var $441=(($440+52)|0);
4830       var $442=HEAP32[(($441)>>2)];
4831       _util_memory_d($442, 172, ((STRING_TABLE.__str)|0));
4832       __label__ = 73; break;
4833     case 73:
4834       var $444=$prog;
4835       var $445=(($444+64)|0);
4836       var $446=HEAP32[(($445)>>2)];
4837       var $447=(($446)|0)!=0;
4838       if ($447) { __label__ = 74; break; } else { __label__ = 75; break; }
4839     case 74:
4840       var $449=$prog;
4841       var $450=(($449+64)|0);
4842       var $451=HEAP32[(($450)>>2)];
4843       var $452=$451;
4844       _util_memory_d($452, 173, ((STRING_TABLE.__str)|0));
4845       __label__ = 75; break;
4846     case 75:
4847       var $454=$prog;
4848       var $455=(($454+76)|0);
4849       var $456=HEAP32[(($455)>>2)];
4850       var $457=(($456)|0)!=0;
4851       if ($457) { __label__ = 76; break; } else { __label__ = 77; break; }
4852     case 76:
4853       var $459=$prog;
4854       var $460=(($459+76)|0);
4855       var $461=HEAP32[(($460)>>2)];
4856       var $462=$461;
4857       _util_memory_d($462, 174, ((STRING_TABLE.__str)|0));
4858       __label__ = 77; break;
4859     case 77:
4860       var $464=$prog;
4861       var $465=(($464+88)|0);
4862       var $466=HEAP32[(($465)>>2)];
4863       var $467=(($466)|0)!=0;
4864       if ($467) { __label__ = 78; break; } else { __label__ = 79; break; }
4865     case 78:
4866       var $469=$prog;
4867       var $470=(($469+88)|0);
4868       var $471=HEAP32[(($470)>>2)];
4869       _util_memory_d($471, 175, ((STRING_TABLE.__str)|0));
4870       __label__ = 79; break;
4871     case 79:
4872       var $473=$prog;
4873       var $474=$473;
4874       _util_memory_d($474, 176, ((STRING_TABLE.__str)|0));
4875       $1=0;
4876       __label__ = 80; break;
4877     case 80:
4878       var $476=$1;
4879       STACKTOP = __stackBase__;
4880       return $476;
4881     default: assert(0, "bad label: " + __label__);
4882   }
4883 }
4884 _prog_load["X"]=1;
4885
4886 function _loaderror($fmt) {
4887   var __stackBase__  = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
4888   var __label__;
4889
4890   var $1;
4891   var $err;
4892   var $ap=__stackBase__;
4893   $1=$fmt;
4894   var $2=___errno();
4895   var $3=HEAP32[(($2)>>2)];
4896   $err=$3;
4897   var $4=$ap;
4898   HEAP32[(($4)>>2)]=arguments[_loaderror.length];
4899   var $5=$1;
4900   var $6=HEAP32[(($ap)>>2)];
4901   var $7=_vprintf($5, $6);
4902   var $8=$ap;
4903   ;
4904   var $9=$err;
4905   var $10=_strerror($9);
4906   var $11=_printf(((STRING_TABLE.__str110)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10,tempInt));
4907   STACKTOP = __stackBase__;
4908   return;
4909 }
4910
4911
4912 function _prog_getstring($prog, $str) {
4913   ;
4914   var __label__;
4915   __label__ = 2;
4916   while(1) switch(__label__) {
4917     case 2:
4918       var $1;
4919       var $2;
4920       var $3;
4921       $2=$prog;
4922       $3=$str;
4923       var $4=$3;
4924       var $5=(($4)|0) < 0;
4925       if ($5) { __label__ = 4; break; } else { __label__ = 3; break; }
4926     case 3:
4927       var $7=$3;
4928       var $8=$2;
4929       var $9=(($8+56)|0);
4930       var $10=HEAP32[(($9)>>2)];
4931       var $11=(($7)>>>0) >= (($10)>>>0);
4932       if ($11) { __label__ = 4; break; } else { __label__ = 5; break; }
4933     case 4:
4934       $1=((STRING_TABLE.__str10)|0);
4935       __label__ = 6; break;
4936     case 5:
4937       var $14=$2;
4938       var $15=(($14+52)|0);
4939       var $16=HEAP32[(($15)>>2)];
4940       var $17=$3;
4941       var $18=(($16+$17)|0);
4942       $1=$18;
4943       __label__ = 6; break;
4944     case 6:
4945       var $20=$1;
4946       ;
4947       return $20;
4948     default: assert(0, "bad label: " + __label__);
4949   }
4950 }
4951
4952
4953 function _prog_entfield($prog, $off) {
4954   ;
4955   var __label__;
4956   __label__ = 2;
4957   while(1) switch(__label__) {
4958     case 2:
4959       var $1;
4960       var $2;
4961       var $3;
4962       var $i;
4963       $2=$prog;
4964       $3=$off;
4965       $i=0;
4966       __label__ = 3; break;
4967     case 3:
4968       var $5=$i;
4969       var $6=$2;
4970       var $7=(($6+32)|0);
4971       var $8=HEAP32[(($7)>>2)];
4972       var $9=(($5)>>>0) < (($8)>>>0);
4973       if ($9) { __label__ = 4; break; } else { __label__ = 8; break; }
4974     case 4:
4975       var $11=$i;
4976       var $12=$2;
4977       var $13=(($12+28)|0);
4978       var $14=HEAP32[(($13)>>2)];
4979       var $15=(($14+($11<<3))|0);
4980       var $16=(($15+2)|0);
4981       var $17=HEAP16[(($16)>>1)];
4982       var $18=(($17)&65535);
4983       var $19=$3;
4984       var $20=(($18)|0)==(($19)|0);
4985       if ($20) { __label__ = 5; break; } else { __label__ = 6; break; }
4986     case 5:
4987       var $22=$2;
4988       var $23=(($22+28)|0);
4989       var $24=HEAP32[(($23)>>2)];
4990       var $25=$i;
4991       var $26=(($24+($25<<3))|0);
4992       $1=$26;
4993       __label__ = 9; break;
4994     case 6:
4995       __label__ = 7; break;
4996     case 7:
4997       var $29=$i;
4998       var $30=((($29)+(1))|0);
4999       $i=$30;
5000       __label__ = 3; break;
5001     case 8:
5002       $1=0;
5003       __label__ = 9; break;
5004     case 9:
5005       var $33=$1;
5006       ;
5007       return $33;
5008     default: assert(0, "bad label: " + __label__);
5009   }
5010 }
5011
5012
5013 function _prog_getdef($prog, $off) {
5014   ;
5015   var __label__;
5016   __label__ = 2;
5017   while(1) switch(__label__) {
5018     case 2:
5019       var $1;
5020       var $2;
5021       var $3;
5022       var $i;
5023       $2=$prog;
5024       $3=$off;
5025       $i=0;
5026       __label__ = 3; break;
5027     case 3:
5028       var $5=$i;
5029       var $6=$2;
5030       var $7=(($6+20)|0);
5031       var $8=HEAP32[(($7)>>2)];
5032       var $9=(($5)>>>0) < (($8)>>>0);
5033       if ($9) { __label__ = 4; break; } else { __label__ = 8; break; }
5034     case 4:
5035       var $11=$i;
5036       var $12=$2;
5037       var $13=(($12+16)|0);
5038       var $14=HEAP32[(($13)>>2)];
5039       var $15=(($14+($11<<3))|0);
5040       var $16=(($15+2)|0);
5041       var $17=HEAP16[(($16)>>1)];
5042       var $18=(($17)&65535);
5043       var $19=$3;
5044       var $20=(($18)|0)==(($19)|0);
5045       if ($20) { __label__ = 5; break; } else { __label__ = 6; break; }
5046     case 5:
5047       var $22=$2;
5048       var $23=(($22+16)|0);
5049       var $24=HEAP32[(($23)>>2)];
5050       var $25=$i;
5051       var $26=(($24+($25<<3))|0);
5052       $1=$26;
5053       __label__ = 9; break;
5054     case 6:
5055       __label__ = 7; break;
5056     case 7:
5057       var $29=$i;
5058       var $30=((($29)+(1))|0);
5059       $i=$30;
5060       __label__ = 3; break;
5061     case 8:
5062       $1=0;
5063       __label__ = 9; break;
5064     case 9:
5065       var $33=$1;
5066       ;
5067       return $33;
5068     default: assert(0, "bad label: " + __label__);
5069   }
5070 }
5071
5072
5073 function _prog_delete($prog) {
5074   ;
5075   var __label__;
5076   __label__ = 2;
5077   while(1) switch(__label__) {
5078     case 2:
5079       var $1;
5080       $1=$prog;
5081       var $2=$1;
5082       var $3=(($2)|0);
5083       var $4=HEAP32[(($3)>>2)];
5084       var $5=(($4)|0)!=0;
5085       if ($5) { __label__ = 3; break; } else { __label__ = 4; break; }
5086     case 3:
5087       var $7=$1;
5088       var $8=(($7)|0);
5089       var $9=HEAP32[(($8)>>2)];
5090       _util_memory_d($9, 182, ((STRING_TABLE.__str)|0));
5091       __label__ = 4; break;
5092     case 4:
5093       var $11=$1;
5094       var $12=(($11+4)|0);
5095       var $13=HEAP32[(($12)>>2)];
5096       var $14=(($13)|0)!=0;
5097       if ($14) { __label__ = 5; break; } else { __label__ = 6; break; }
5098     case 5:
5099       var $16=$1;
5100       var $17=(($16+4)|0);
5101       var $18=HEAP32[(($17)>>2)];
5102       var $19=$18;
5103       _util_memory_d($19, 183, ((STRING_TABLE.__str)|0));
5104       __label__ = 6; break;
5105     case 6:
5106       var $21=$1;
5107       var $22=(($21+4)|0);
5108       HEAP32[(($22)>>2)]=0;
5109       var $23=$1;
5110       var $24=(($23+8)|0);
5111       HEAP32[(($24)>>2)]=0;
5112       var $25=$1;
5113       var $26=(($25+12)|0);
5114       HEAP32[(($26)>>2)]=0;
5115       var $27=$1;
5116       var $28=(($27+16)|0);
5117       var $29=HEAP32[(($28)>>2)];
5118       var $30=(($29)|0)!=0;
5119       if ($30) { __label__ = 7; break; } else { __label__ = 8; break; }
5120     case 7:
5121       var $32=$1;
5122       var $33=(($32+16)|0);
5123       var $34=HEAP32[(($33)>>2)];
5124       var $35=$34;
5125       _util_memory_d($35, 184, ((STRING_TABLE.__str)|0));
5126       __label__ = 8; break;
5127     case 8:
5128       var $37=$1;
5129       var $38=(($37+16)|0);
5130       HEAP32[(($38)>>2)]=0;
5131       var $39=$1;
5132       var $40=(($39+20)|0);
5133       HEAP32[(($40)>>2)]=0;
5134       var $41=$1;
5135       var $42=(($41+24)|0);
5136       HEAP32[(($42)>>2)]=0;
5137       var $43=$1;
5138       var $44=(($43+28)|0);
5139       var $45=HEAP32[(($44)>>2)];
5140       var $46=(($45)|0)!=0;
5141       if ($46) { __label__ = 9; break; } else { __label__ = 10; break; }
5142     case 9:
5143       var $48=$1;
5144       var $49=(($48+28)|0);
5145       var $50=HEAP32[(($49)>>2)];
5146       var $51=$50;
5147       _util_memory_d($51, 185, ((STRING_TABLE.__str)|0));
5148       __label__ = 10; break;
5149     case 10:
5150       var $53=$1;
5151       var $54=(($53+28)|0);
5152       HEAP32[(($54)>>2)]=0;
5153       var $55=$1;
5154       var $56=(($55+32)|0);
5155       HEAP32[(($56)>>2)]=0;
5156       var $57=$1;
5157       var $58=(($57+36)|0);
5158       HEAP32[(($58)>>2)]=0;
5159       var $59=$1;
5160       var $60=(($59+40)|0);
5161       var $61=HEAP32[(($60)>>2)];
5162       var $62=(($61)|0)!=0;
5163       if ($62) { __label__ = 11; break; } else { __label__ = 12; break; }
5164     case 11:
5165       var $64=$1;
5166       var $65=(($64+40)|0);
5167       var $66=HEAP32[(($65)>>2)];
5168       var $67=$66;
5169       _util_memory_d($67, 186, ((STRING_TABLE.__str)|0));
5170       __label__ = 12; break;
5171     case 12:
5172       var $69=$1;
5173       var $70=(($69+40)|0);
5174       HEAP32[(($70)>>2)]=0;
5175       var $71=$1;
5176       var $72=(($71+44)|0);
5177       HEAP32[(($72)>>2)]=0;
5178       var $73=$1;
5179       var $74=(($73+48)|0);
5180       HEAP32[(($74)>>2)]=0;
5181       var $75=$1;
5182       var $76=(($75+52)|0);
5183       var $77=HEAP32[(($76)>>2)];
5184       var $78=(($77)|0)!=0;
5185       if ($78) { __label__ = 13; break; } else { __label__ = 14; break; }
5186     case 13:
5187       var $80=$1;
5188       var $81=(($80+52)|0);
5189       var $82=HEAP32[(($81)>>2)];
5190       _util_memory_d($82, 187, ((STRING_TABLE.__str)|0));
5191       __label__ = 14; break;
5192     case 14:
5193       var $84=$1;
5194       var $85=(($84+52)|0);
5195       HEAP32[(($85)>>2)]=0;
5196       var $86=$1;
5197       var $87=(($86+56)|0);
5198       HEAP32[(($87)>>2)]=0;
5199       var $88=$1;
5200       var $89=(($88+60)|0);
5201       HEAP32[(($89)>>2)]=0;
5202       var $90=$1;
5203       var $91=(($90+64)|0);
5204       var $92=HEAP32[(($91)>>2)];
5205       var $93=(($92)|0)!=0;
5206       if ($93) { __label__ = 15; break; } else { __label__ = 16; break; }
5207     case 15:
5208       var $95=$1;
5209       var $96=(($95+64)|0);
5210       var $97=HEAP32[(($96)>>2)];
5211       var $98=$97;
5212       _util_memory_d($98, 188, ((STRING_TABLE.__str)|0));
5213       __label__ = 16; break;
5214     case 16:
5215       var $100=$1;
5216       var $101=(($100+64)|0);
5217       HEAP32[(($101)>>2)]=0;
5218       var $102=$1;
5219       var $103=(($102+68)|0);
5220       HEAP32[(($103)>>2)]=0;
5221       var $104=$1;
5222       var $105=(($104+72)|0);
5223       HEAP32[(($105)>>2)]=0;
5224       var $106=$1;
5225       var $107=(($106+76)|0);
5226       var $108=HEAP32[(($107)>>2)];
5227       var $109=(($108)|0)!=0;
5228       if ($109) { __label__ = 17; break; } else { __label__ = 18; break; }
5229     case 17:
5230       var $111=$1;
5231       var $112=(($111+76)|0);
5232       var $113=HEAP32[(($112)>>2)];
5233       var $114=$113;
5234       _util_memory_d($114, 189, ((STRING_TABLE.__str)|0));
5235       __label__ = 18; break;
5236     case 18:
5237       var $116=$1;
5238       var $117=(($116+76)|0);
5239       HEAP32[(($117)>>2)]=0;
5240       var $118=$1;
5241       var $119=(($118+80)|0);
5242       HEAP32[(($119)>>2)]=0;
5243       var $120=$1;
5244       var $121=(($120+84)|0);
5245       HEAP32[(($121)>>2)]=0;
5246       var $122=$1;
5247       var $123=(($122+88)|0);
5248       var $124=HEAP32[(($123)>>2)];
5249       var $125=(($124)|0)!=0;
5250       if ($125) { __label__ = 19; break; } else { __label__ = 20; break; }
5251     case 19:
5252       var $127=$1;
5253       var $128=(($127+88)|0);
5254       var $129=HEAP32[(($128)>>2)];
5255       _util_memory_d($129, 190, ((STRING_TABLE.__str)|0));
5256       __label__ = 20; break;
5257     case 20:
5258       var $131=$1;
5259       var $132=(($131+88)|0);
5260       HEAP32[(($132)>>2)]=0;
5261       var $133=$1;
5262       var $134=(($133+92)|0);
5263       HEAP32[(($134)>>2)]=0;
5264       var $135=$1;
5265       var $136=(($135+96)|0);
5266       HEAP32[(($136)>>2)]=0;
5267       var $137=$1;
5268       var $138=(($137+152)|0);
5269       var $139=HEAP32[(($138)>>2)];
5270       var $140=(($139)|0)!=0;
5271       if ($140) { __label__ = 21; break; } else { __label__ = 22; break; }
5272     case 21:
5273       var $142=$1;
5274       var $143=(($142+152)|0);
5275       var $144=HEAP32[(($143)>>2)];
5276       var $145=$144;
5277       _util_memory_d($145, 191, ((STRING_TABLE.__str)|0));
5278       __label__ = 22; break;
5279     case 22:
5280       var $147=$1;
5281       var $148=(($147+152)|0);
5282       HEAP32[(($148)>>2)]=0;
5283       var $149=$1;
5284       var $150=(($149+156)|0);
5285       HEAP32[(($150)>>2)]=0;
5286       var $151=$1;
5287       var $152=(($151+160)|0);
5288       HEAP32[(($152)>>2)]=0;
5289       var $153=$1;
5290       var $154=(($153+164)|0);
5291       var $155=HEAP32[(($154)>>2)];
5292       var $156=(($155)|0)!=0;
5293       if ($156) { __label__ = 23; break; } else { __label__ = 24; break; }
5294     case 23:
5295       var $158=$1;
5296       var $159=(($158+164)|0);
5297       var $160=HEAP32[(($159)>>2)];
5298       var $161=$160;
5299       _util_memory_d($161, 192, ((STRING_TABLE.__str)|0));
5300       __label__ = 24; break;
5301     case 24:
5302       var $163=$1;
5303       var $164=(($163+164)|0);
5304       HEAP32[(($164)>>2)]=0;
5305       var $165=$1;
5306       var $166=(($165+168)|0);
5307       HEAP32[(($166)>>2)]=0;
5308       var $167=$1;
5309       var $168=(($167+172)|0);
5310       HEAP32[(($168)>>2)]=0;
5311       var $169=$1;
5312       var $170=(($169+116)|0);
5313       var $171=HEAP32[(($170)>>2)];
5314       var $172=(($171)|0)!=0;
5315       if ($172) { __label__ = 25; break; } else { __label__ = 26; break; }
5316     case 25:
5317       var $174=$1;
5318       var $175=(($174+116)|0);
5319       var $176=HEAP32[(($175)>>2)];
5320       var $177=$176;
5321       _util_memory_d($177, 193, ((STRING_TABLE.__str)|0));
5322       __label__ = 26; break;
5323     case 26:
5324       var $179=$1;
5325       var $180=(($179+116)|0);
5326       HEAP32[(($180)>>2)]=0;
5327       var $181=$1;
5328       var $182=(($181+120)|0);
5329       HEAP32[(($182)>>2)]=0;
5330       var $183=$1;
5331       var $184=(($183+124)|0);
5332       HEAP32[(($184)>>2)]=0;
5333       var $185=$1;
5334       var $186=(($185+136)|0);
5335       var $187=HEAP32[(($186)>>2)];
5336       var $188=(($187)|0)!=0;
5337       if ($188) { __label__ = 27; break; } else { __label__ = 30; break; }
5338     case 27:
5339       var $190=$1;
5340       var $191=(($190+128)|0);
5341       var $192=HEAP32[(($191)>>2)];
5342       var $193=(($192)|0)!=0;
5343       if ($193) { __label__ = 28; break; } else { __label__ = 29; break; }
5344     case 28:
5345       var $195=$1;
5346       var $196=(($195+128)|0);
5347       var $197=HEAP32[(($196)>>2)];
5348       var $198=$197;
5349       _util_memory_d($198, 196, ((STRING_TABLE.__str)|0));
5350       __label__ = 29; break;
5351     case 29:
5352       var $200=$1;
5353       var $201=(($200+128)|0);
5354       HEAP32[(($201)>>2)]=0;
5355       var $202=$1;
5356       var $203=(($202+132)|0);
5357       HEAP32[(($203)>>2)]=0;
5358       var $204=$1;
5359       var $205=(($204+136)|0);
5360       HEAP32[(($205)>>2)]=0;
5361       __label__ = 30; break;
5362     case 30:
5363       var $207=$1;
5364       var $208=$207;
5365       _util_memory_d($208, 199, ((STRING_TABLE.__str)|0));
5366       ;
5367       return;
5368     default: assert(0, "bad label: " + __label__);
5369   }
5370 }
5371 _prog_delete["X"]=1;
5372
5373 function _prog_getedict($prog, $e) {
5374   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5375   var __label__;
5376   __label__ = 2;
5377   while(1) switch(__label__) {
5378     case 2:
5379       var $1;
5380       var $2;
5381       $1=$prog;
5382       $2=$e;
5383       var $3=$2;
5384       var $4=$1;
5385       var $5=(($4+92)|0);
5386       var $6=HEAP32[(($5)>>2)];
5387       var $7=(($3)>>>0) >= (($6)>>>0);
5388       if ($7) { __label__ = 3; break; } else { __label__ = 4; break; }
5389     case 3:
5390       var $9=$1;
5391       var $10=(($9+112)|0);
5392       var $11=HEAP32[(($10)>>2)];
5393       var $12=((($11)+(1))|0);
5394       HEAP32[(($10)>>2)]=$12;
5395       var $13=$2;
5396       var $14=_printf(((STRING_TABLE.__str11)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$13,tempInt));
5397       $2=0;
5398       __label__ = 4; break;
5399     case 4:
5400       var $16=$1;
5401       var $17=(($16+76)|0);
5402       var $18=HEAP32[(($17)>>2)];
5403       var $19=$1;
5404       var $20=(($19+144)|0);
5405       var $21=HEAP32[(($20)>>2)];
5406       var $22=$2;
5407       var $23=((($21)*($22))|0);
5408       var $24=(($18+($23<<2))|0);
5409       var $25=$24;
5410       STACKTOP = __stackBase__;
5411       return $25;
5412     default: assert(0, "bad label: " + __label__);
5413   }
5414 }
5415
5416
5417 function _prog_spawn_entity($prog) {
5418   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5419   var __label__;
5420   __label__ = 2;
5421   while(1) switch(__label__) {
5422     case 2:
5423       var $1;
5424       var $2;
5425       var $data;
5426       var $i;
5427       var $e;
5428       $2=$prog;
5429       $e=0;
5430       __label__ = 3; break;
5431     case 3:
5432       var $4=$e;
5433       var $5=$2;
5434       var $6=(($5+92)|0);
5435       var $7=HEAP32[(($6)>>2)];
5436       var $8=(($4)|0) < (($7)|0);
5437       if ($8) { __label__ = 4; break; } else { __label__ = 8; break; }
5438     case 4:
5439       var $10=$e;
5440       var $11=$2;
5441       var $12=(($11+88)|0);
5442       var $13=HEAP32[(($12)>>2)];
5443       var $14=(($13+$10)|0);
5444       var $15=HEAP8[($14)];
5445       var $16=(($15) & 1);
5446       if ($16) { __label__ = 6; break; } else { __label__ = 5; break; }
5447     case 5:
5448       var $18=$2;
5449       var $19=(($18+76)|0);
5450       var $20=HEAP32[(($19)>>2)];
5451       var $21=$2;
5452       var $22=(($21+144)|0);
5453       var $23=HEAP32[(($22)>>2)];
5454       var $24=$e;
5455       var $25=((($23)*($24))|0);
5456       var $26=(($20+($25<<2))|0);
5457       var $27=$26;
5458       $data=$27;
5459       var $28=$data;
5460       var $29=$2;
5461       var $30=(($29+144)|0);
5462       var $31=HEAP32[(($30)>>2)];
5463       var $32=((($31<<2))|0);
5464       _memset($28, 0, $32, 1);
5465       var $33=$e;
5466       $1=$33;
5467       __label__ = 17; break;
5468     case 6:
5469       __label__ = 7; break;
5470     case 7:
5471       var $36=$e;
5472       var $37=((($36)+(1))|0);
5473       $e=$37;
5474       __label__ = 3; break;
5475     case 8:
5476       var $39=$2;
5477       var $40=_qc_program_entitypool_add($39, 1);
5478       if ($40) { __label__ = 10; break; } else { __label__ = 9; break; }
5479     case 9:
5480       var $42=$2;
5481       var $43=(($42+112)|0);
5482       var $44=HEAP32[(($43)>>2)];
5483       var $45=((($44)+(1))|0);
5484       HEAP32[(($43)>>2)]=$45;
5485       var $46=_printf(((STRING_TABLE.__str12)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
5486       $1=0;
5487       __label__ = 17; break;
5488     case 10:
5489       var $48=$2;
5490       var $49=(($48+140)|0);
5491       var $50=HEAP32[(($49)>>2)];
5492       var $51=((($50)+(1))|0);
5493       HEAP32[(($49)>>2)]=$51;
5494       $i=0;
5495       __label__ = 11; break;
5496     case 11:
5497       var $53=$i;
5498       var $54=$2;
5499       var $55=(($54+144)|0);
5500       var $56=HEAP32[(($55)>>2)];
5501       var $57=(($53)>>>0) < (($56)>>>0);
5502       if ($57) { __label__ = 12; break; } else { __label__ = 16; break; }
5503     case 12:
5504       var $59=$2;
5505       var $60=_qc_program_entitydata_add($59, 0);
5506       if ($60) { __label__ = 14; break; } else { __label__ = 13; break; }
5507     case 13:
5508       var $62=_printf(((STRING_TABLE.__str12)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
5509       $1=0;
5510       __label__ = 17; break;
5511     case 14:
5512       __label__ = 15; break;
5513     case 15:
5514       var $65=$i;
5515       var $66=((($65)+(1))|0);
5516       $i=$66;
5517       __label__ = 11; break;
5518     case 16:
5519       var $68=$2;
5520       var $69=(($68+76)|0);
5521       var $70=HEAP32[(($69)>>2)];
5522       var $71=$2;
5523       var $72=(($71+144)|0);
5524       var $73=HEAP32[(($72)>>2)];
5525       var $74=$e;
5526       var $75=((($73)*($74))|0);
5527       var $76=(($70+($75<<2))|0);
5528       var $77=$76;
5529       $data=$77;
5530       var $78=$data;
5531       var $79=$2;
5532       var $80=(($79+144)|0);
5533       var $81=HEAP32[(($80)>>2)];
5534       var $82=((($81<<2))|0);
5535       _memset($78, 0, $82, 1);
5536       var $83=$e;
5537       $1=$83;
5538       __label__ = 17; break;
5539     case 17:
5540       var $85=$1;
5541       STACKTOP = __stackBase__;
5542       return $85;
5543     default: assert(0, "bad label: " + __label__);
5544   }
5545 }
5546 _prog_spawn_entity["X"]=1;
5547
5548 function _prog_free_entity($prog, $e) {
5549   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5550   var __label__;
5551   __label__ = 2;
5552   while(1) switch(__label__) {
5553     case 2:
5554       var $1;
5555       var $2;
5556       $1=$prog;
5557       $2=$e;
5558       var $3=$2;
5559       var $4=(($3)|0)!=0;
5560       if ($4) { __label__ = 4; break; } else { __label__ = 3; break; }
5561     case 3:
5562       var $6=$1;
5563       var $7=(($6+112)|0);
5564       var $8=HEAP32[(($7)>>2)];
5565       var $9=((($8)+(1))|0);
5566       HEAP32[(($7)>>2)]=$9;
5567       var $10=_printf(((STRING_TABLE.__str13)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
5568       __label__ = 9; break;
5569     case 4:
5570       var $12=$2;
5571       var $13=$1;
5572       var $14=(($13+92)|0);
5573       var $15=HEAP32[(($14)>>2)];
5574       var $16=(($12)>>>0) >= (($15)>>>0);
5575       if ($16) { __label__ = 5; break; } else { __label__ = 6; break; }
5576     case 5:
5577       var $18=$1;
5578       var $19=(($18+112)|0);
5579       var $20=HEAP32[(($19)>>2)];
5580       var $21=((($20)+(1))|0);
5581       HEAP32[(($19)>>2)]=$21;
5582       var $22=_printf(((STRING_TABLE.__str14)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
5583       __label__ = 9; break;
5584     case 6:
5585       var $24=$2;
5586       var $25=$1;
5587       var $26=(($25+88)|0);
5588       var $27=HEAP32[(($26)>>2)];
5589       var $28=(($27+$24)|0);
5590       var $29=HEAP8[($28)];
5591       var $30=(($29) & 1);
5592       if ($30) { __label__ = 8; break; } else { __label__ = 7; break; }
5593     case 7:
5594       var $32=$1;
5595       var $33=(($32+112)|0);
5596       var $34=HEAP32[(($33)>>2)];
5597       var $35=((($34)+(1))|0);
5598       HEAP32[(($33)>>2)]=$35;
5599       var $36=_printf(((STRING_TABLE.__str15)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
5600       __label__ = 9; break;
5601     case 8:
5602       var $38=$2;
5603       var $39=$1;
5604       var $40=(($39+88)|0);
5605       var $41=HEAP32[(($40)>>2)];
5606       var $42=(($41+$38)|0);
5607       HEAP8[($42)]=0;
5608       __label__ = 9; break;
5609     case 9:
5610       STACKTOP = __stackBase__;
5611       return;
5612     default: assert(0, "bad label: " + __label__);
5613   }
5614 }
5615 _prog_free_entity["X"]=1;
5616
5617 function _prog_tempstring($prog, $_str) {
5618   ;
5619   var __label__;
5620   __label__ = 2;
5621   while(1) switch(__label__) {
5622     case 2:
5623       var $1;
5624       var $2;
5625       var $3;
5626       var $str;
5627       var $len;
5628       var $at;
5629       $2=$prog;
5630       $3=$_str;
5631       var $4=$3;
5632       $str=$4;
5633       var $5=$str;
5634       var $6=_strlen($5);
5635       $len=$6;
5636       var $7=$2;
5637       var $8=(($7+108)|0);
5638       var $9=HEAP32[(($8)>>2)];
5639       $at=$9;
5640       var $10=$at;
5641       var $11=$len;
5642       var $12=((($10)+($11))|0);
5643       var $13=$2;
5644       var $14=(($13+56)|0);
5645       var $15=HEAP32[(($14)>>2)];
5646       var $16=(($12)>>>0) >= (($15)>>>0);
5647       if ($16) { __label__ = 3; break; } else { __label__ = 4; break; }
5648     case 3:
5649       var $18=$2;
5650       var $19=(($18+104)|0);
5651       var $20=HEAP32[(($19)>>2)];
5652       $at=$20;
5653       __label__ = 4; break;
5654     case 4:
5655       var $22=$at;
5656       var $23=$len;
5657       var $24=((($22)+($23))|0);
5658       var $25=$2;
5659       var $26=(($25+56)|0);
5660       var $27=HEAP32[(($26)>>2)];
5661       var $28=(($24)>>>0) >= (($27)>>>0);
5662       if ($28) { __label__ = 5; break; } else { __label__ = 8; break; }
5663     case 5:
5664       var $30=$at;
5665       var $31=$2;
5666       var $32=(($31+56)|0);
5667       HEAP32[(($32)>>2)]=$30;
5668       var $33=$2;
5669       var $34=$str;
5670       var $35=$len;
5671       var $36=((($35)+(1))|0);
5672       var $37=_qc_program_strings_append($33, $34, $36);
5673       if ($37) { __label__ = 7; break; } else { __label__ = 6; break; }
5674     case 6:
5675       var $39=$2;
5676       var $40=(($39+112)|0);
5677       HEAP32[(($40)>>2)]=1;
5678       $1=0;
5679       __label__ = 9; break;
5680     case 7:
5681       var $42=$at;
5682       $1=$42;
5683       __label__ = 9; break;
5684     case 8:
5685       var $44=$2;
5686       var $45=(($44+52)|0);
5687       var $46=HEAP32[(($45)>>2)];
5688       var $47=$at;
5689       var $48=(($46+$47)|0);
5690       var $49=$str;
5691       var $50=$len;
5692       var $51=((($50)+(1))|0);
5693       assert($51 % 1 === 0, 'memcpy given ' + $51 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($48, $49, $51, 1);
5694       var $52=$len;
5695       var $53=((($52)+(1))|0);
5696       var $54=$2;
5697       var $55=(($54+108)|0);
5698       var $56=HEAP32[(($55)>>2)];
5699       var $57=((($56)+($53))|0);
5700       HEAP32[(($55)>>2)]=$57;
5701       var $58=$at;
5702       $1=$58;
5703       __label__ = 9; break;
5704     case 9:
5705       var $60=$1;
5706       ;
5707       return $60;
5708     default: assert(0, "bad label: " + __label__);
5709   }
5710 }
5711 _prog_tempstring["X"]=1;
5712
5713 function _prog_exec($prog, $func, $flags, $maxjumps) {
5714   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5715   var __label__;
5716   __label__ = 2;
5717   while(1) switch(__label__) {
5718     case 2:
5719       var $1;
5720       var $2;
5721       var $3;
5722       var $4;
5723       var $5;
5724       var $jumpcount;
5725       var $oldxflags;
5726       var $st;
5727       var $newf;
5728       var $ed;
5729       var $ptr;
5730       var $builtinnumber;
5731       var $newf1;
5732       var $ed2;
5733       var $ptr3;
5734       var $builtinnumber4;
5735       var $newf5;
5736       var $ed6;
5737       var $ptr7;
5738       var $builtinnumber8;
5739       var $newf9;
5740       var $ed10;
5741       var $ptr11;
5742       var $builtinnumber12;
5743       $2=$prog;
5744       $3=$func;
5745       $4=$flags;
5746       $5=$maxjumps;
5747       $jumpcount=0;
5748       var $6=$2;
5749       var $7=(($6+180)|0);
5750       var $8=HEAP32[(($7)>>2)];
5751       $oldxflags=$8;
5752       var $9=$2;
5753       var $10=(($9+112)|0);
5754       HEAP32[(($10)>>2)]=0;
5755       var $11=$4;
5756       var $12=$2;
5757       var $13=(($12+180)|0);
5758       HEAP32[(($13)>>2)]=$11;
5759       var $14=$2;
5760       var $15=(($14+4)|0);
5761       var $16=HEAP32[(($15)>>2)];
5762       var $17=$2;
5763       var $18=$3;
5764       var $19=_prog_enterfunction($17, $18);
5765       var $20=(($16+($19<<3))|0);
5766       $st=$20;
5767       var $21=$st;
5768       var $22=((($21)-(8))|0);
5769       $st=$22;
5770       var $23=$4;
5771       if ((($23)|0) == 0) {
5772         __label__ = 4; break;
5773       }
5774       else if ((($23)|0) == 1) {
5775         __label__ = 125; break;
5776       }
5777       else if ((($23)|0) == 2) {
5778         __label__ = 246; break;
5779       }
5780       else if ((($23)|0) == 3) {
5781         __label__ = 367; break;
5782       }
5783       else {
5784       __label__ = 3; break;
5785       }
5786
5787     case 3:
5788       __label__ = 4; break;
5789     case 4:
5790       __label__ = 5; break;
5791     case 5:
5792       var $27=$st;
5793       var $28=(($27+8)|0);
5794       $st=$28;
5795       var $29=$st;
5796       var $30=(($29)|0);
5797       var $31=HEAP16[(($30)>>1)];
5798       var $32=(($31)&65535);
5799       if ((($32)|0) == 0 || (($32)|0) == 43) {
5800         __label__ = 7; break;
5801       }
5802       else if ((($32)|0) == 1) {
5803         __label__ = 10; break;
5804       }
5805       else if ((($32)|0) == 2) {
5806         __label__ = 11; break;
5807       }
5808       else if ((($32)|0) == 3) {
5809         __label__ = 12; break;
5810       }
5811       else if ((($32)|0) == 4) {
5812         __label__ = 13; break;
5813       }
5814       else if ((($32)|0) == 5) {
5815         __label__ = 14; break;
5816       }
5817       else if ((($32)|0) == 6) {
5818         __label__ = 18; break;
5819       }
5820       else if ((($32)|0) == 7) {
5821         __label__ = 19; break;
5822       }
5823       else if ((($32)|0) == 8) {
5824         __label__ = 20; break;
5825       }
5826       else if ((($32)|0) == 9) {
5827         __label__ = 21; break;
5828       }
5829       else if ((($32)|0) == 10) {
5830         __label__ = 22; break;
5831       }
5832       else if ((($32)|0) == 11) {
5833         __label__ = 23; break;
5834       }
5835       else if ((($32)|0) == 12) {
5836         __label__ = 27; break;
5837       }
5838       else if ((($32)|0) == 13) {
5839         __label__ = 28; break;
5840       }
5841       else if ((($32)|0) == 14) {
5842         __label__ = 29; break;
5843       }
5844       else if ((($32)|0) == 15) {
5845         __label__ = 30; break;
5846       }
5847       else if ((($32)|0) == 16) {
5848         __label__ = 31; break;
5849       }
5850       else if ((($32)|0) == 17) {
5851         __label__ = 35; break;
5852       }
5853       else if ((($32)|0) == 18) {
5854         __label__ = 36; break;
5855       }
5856       else if ((($32)|0) == 19) {
5857         __label__ = 37; break;
5858       }
5859       else if ((($32)|0) == 20) {
5860         __label__ = 38; break;
5861       }
5862       else if ((($32)|0) == 21) {
5863         __label__ = 39; break;
5864       }
5865       else if ((($32)|0) == 22) {
5866         __label__ = 40; break;
5867       }
5868       else if ((($32)|0) == 23) {
5869         __label__ = 41; break;
5870       }
5871       else if ((($32)|0) == 24 || (($32)|0) == 26 || (($32)|0) == 28 || (($32)|0) == 27 || (($32)|0) == 29) {
5872         __label__ = 42; break;
5873       }
5874       else if ((($32)|0) == 25) {
5875         __label__ = 48; break;
5876       }
5877       else if ((($32)|0) == 30) {
5878         __label__ = 55; break;
5879       }
5880       else if ((($32)|0) == 31 || (($32)|0) == 33 || (($32)|0) == 34 || (($32)|0) == 35 || (($32)|0) == 36) {
5881         __label__ = 61; break;
5882       }
5883       else if ((($32)|0) == 32) {
5884         __label__ = 62; break;
5885       }
5886       else if ((($32)|0) == 37 || (($32)|0) == 39 || (($32)|0) == 40 || (($32)|0) == 41 || (($32)|0) == 42) {
5887         __label__ = 63; break;
5888       }
5889       else if ((($32)|0) == 38) {
5890         __label__ = 70; break;
5891       }
5892       else if ((($32)|0) == 44) {
5893         __label__ = 77; break;
5894       }
5895       else if ((($32)|0) == 45) {
5896         __label__ = 78; break;
5897       }
5898       else if ((($32)|0) == 46) {
5899         __label__ = 82; break;
5900       }
5901       else if ((($32)|0) == 47) {
5902         __label__ = 85; break;
5903       }
5904       else if ((($32)|0) == 48) {
5905         __label__ = 86; break;
5906       }
5907       else if ((($32)|0) == 49) {
5908         __label__ = 87; break;
5909       }
5910       else if ((($32)|0) == 50) {
5911         __label__ = 92; break;
5912       }
5913       else if ((($32)|0) == 51 || (($32)|0) == 52 || (($32)|0) == 53 || (($32)|0) == 54 || (($32)|0) == 55 || (($32)|0) == 56 || (($32)|0) == 57 || (($32)|0) == 58 || (($32)|0) == 59) {
5914         __label__ = 97; break;
5915       }
5916       else if ((($32)|0) == 60) {
5917         __label__ = 112; break;
5918       }
5919       else if ((($32)|0) == 61) {
5920         __label__ = 113; break;
5921       }
5922       else if ((($32)|0) == 62) {
5923         __label__ = 116; break;
5924       }
5925       else if ((($32)|0) == 63) {
5926         __label__ = 119; break;
5927       }
5928       else if ((($32)|0) == 64) {
5929         __label__ = 122; break;
5930       }
5931       else if ((($32)|0) == 65) {
5932         __label__ = 123; break;
5933       }
5934       else {
5935       __label__ = 6; break;
5936       }
5937
5938     case 6:
5939       var $34=$2;
5940       var $35=$2;
5941       var $36=(($35)|0);
5942       var $37=HEAP32[(($36)>>2)];
5943       _qcvmerror($34, ((STRING_TABLE.__str16)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$37,tempInt));
5944       __label__ = 488; break;
5945     case 7:
5946       var $39=$2;
5947       var $40=(($39+64)|0);
5948       var $41=HEAP32[(($40)>>2)];
5949       var $42=$st;
5950       var $43=(($42+2)|0);
5951       var $44=$43;
5952       var $45=HEAP16[(($44)>>1)];
5953       var $46=(($45)&65535);
5954       var $47=(($41+($46<<2))|0);
5955       var $48=$47;
5956       var $49=$48;
5957       var $50=(($49)|0);
5958       var $51=HEAP32[(($50)>>2)];
5959       var $52=$2;
5960       var $53=(($52+64)|0);
5961       var $54=HEAP32[(($53)>>2)];
5962       var $55=(($54+4)|0);
5963       var $56=$55;
5964       var $57=$56;
5965       var $58=(($57)|0);
5966       HEAP32[(($58)>>2)]=$51;
5967       var $59=$2;
5968       var $60=(($59+64)|0);
5969       var $61=HEAP32[(($60)>>2)];
5970       var $62=$st;
5971       var $63=(($62+2)|0);
5972       var $64=$63;
5973       var $65=HEAP16[(($64)>>1)];
5974       var $66=(($65)&65535);
5975       var $67=(($61+($66<<2))|0);
5976       var $68=$67;
5977       var $69=$68;
5978       var $70=(($69+4)|0);
5979       var $71=HEAP32[(($70)>>2)];
5980       var $72=$2;
5981       var $73=(($72+64)|0);
5982       var $74=HEAP32[(($73)>>2)];
5983       var $75=(($74+4)|0);
5984       var $76=$75;
5985       var $77=$76;
5986       var $78=(($77+4)|0);
5987       HEAP32[(($78)>>2)]=$71;
5988       var $79=$2;
5989       var $80=(($79+64)|0);
5990       var $81=HEAP32[(($80)>>2)];
5991       var $82=$st;
5992       var $83=(($82+2)|0);
5993       var $84=$83;
5994       var $85=HEAP16[(($84)>>1)];
5995       var $86=(($85)&65535);
5996       var $87=(($81+($86<<2))|0);
5997       var $88=$87;
5998       var $89=$88;
5999       var $90=(($89+8)|0);
6000       var $91=HEAP32[(($90)>>2)];
6001       var $92=$2;
6002       var $93=(($92+64)|0);
6003       var $94=HEAP32[(($93)>>2)];
6004       var $95=(($94+4)|0);
6005       var $96=$95;
6006       var $97=$96;
6007       var $98=(($97+8)|0);
6008       HEAP32[(($98)>>2)]=$91;
6009       var $99=$2;
6010       var $100=(($99+4)|0);
6011       var $101=HEAP32[(($100)>>2)];
6012       var $102=$2;
6013       var $103=_prog_leavefunction($102);
6014       var $104=(($101+($103<<3))|0);
6015       $st=$104;
6016       var $105=$2;
6017       var $106=(($105+168)|0);
6018       var $107=HEAP32[(($106)>>2)];
6019       var $108=(($107)|0)!=0;
6020       if ($108) { __label__ = 9; break; } else { __label__ = 8; break; }
6021     case 8:
6022       __label__ = 488; break;
6023     case 9:
6024       __label__ = 124; break;
6025     case 10:
6026       var $112=$2;
6027       var $113=(($112+64)|0);
6028       var $114=HEAP32[(($113)>>2)];
6029       var $115=$st;
6030       var $116=(($115+2)|0);
6031       var $117=$116;
6032       var $118=HEAP16[(($117)>>1)];
6033       var $119=(($118)&65535);
6034       var $120=(($114+($119<<2))|0);
6035       var $121=$120;
6036       var $122=$121;
6037       var $123=HEAPF32[(($122)>>2)];
6038       var $124=$2;
6039       var $125=(($124+64)|0);
6040       var $126=HEAP32[(($125)>>2)];
6041       var $127=$st;
6042       var $128=(($127+4)|0);
6043       var $129=$128;
6044       var $130=HEAP16[(($129)>>1)];
6045       var $131=(($130)&65535);
6046       var $132=(($126+($131<<2))|0);
6047       var $133=$132;
6048       var $134=$133;
6049       var $135=HEAPF32[(($134)>>2)];
6050       var $136=($123)*($135);
6051       var $137=$2;
6052       var $138=(($137+64)|0);
6053       var $139=HEAP32[(($138)>>2)];
6054       var $140=$st;
6055       var $141=(($140+6)|0);
6056       var $142=$141;
6057       var $143=HEAP16[(($142)>>1)];
6058       var $144=(($143)&65535);
6059       var $145=(($139+($144<<2))|0);
6060       var $146=$145;
6061       var $147=$146;
6062       HEAPF32[(($147)>>2)]=$136;
6063       __label__ = 124; break;
6064     case 11:
6065       var $149=$2;
6066       var $150=(($149+64)|0);
6067       var $151=HEAP32[(($150)>>2)];
6068       var $152=$st;
6069       var $153=(($152+2)|0);
6070       var $154=$153;
6071       var $155=HEAP16[(($154)>>1)];
6072       var $156=(($155)&65535);
6073       var $157=(($151+($156<<2))|0);
6074       var $158=$157;
6075       var $159=$158;
6076       var $160=(($159)|0);
6077       var $161=HEAPF32[(($160)>>2)];
6078       var $162=$2;
6079       var $163=(($162+64)|0);
6080       var $164=HEAP32[(($163)>>2)];
6081       var $165=$st;
6082       var $166=(($165+4)|0);
6083       var $167=$166;
6084       var $168=HEAP16[(($167)>>1)];
6085       var $169=(($168)&65535);
6086       var $170=(($164+($169<<2))|0);
6087       var $171=$170;
6088       var $172=$171;
6089       var $173=(($172)|0);
6090       var $174=HEAPF32[(($173)>>2)];
6091       var $175=($161)*($174);
6092       var $176=$2;
6093       var $177=(($176+64)|0);
6094       var $178=HEAP32[(($177)>>2)];
6095       var $179=$st;
6096       var $180=(($179+2)|0);
6097       var $181=$180;
6098       var $182=HEAP16[(($181)>>1)];
6099       var $183=(($182)&65535);
6100       var $184=(($178+($183<<2))|0);
6101       var $185=$184;
6102       var $186=$185;
6103       var $187=(($186+4)|0);
6104       var $188=HEAPF32[(($187)>>2)];
6105       var $189=$2;
6106       var $190=(($189+64)|0);
6107       var $191=HEAP32[(($190)>>2)];
6108       var $192=$st;
6109       var $193=(($192+4)|0);
6110       var $194=$193;
6111       var $195=HEAP16[(($194)>>1)];
6112       var $196=(($195)&65535);
6113       var $197=(($191+($196<<2))|0);
6114       var $198=$197;
6115       var $199=$198;
6116       var $200=(($199+4)|0);
6117       var $201=HEAPF32[(($200)>>2)];
6118       var $202=($188)*($201);
6119       var $203=($175)+($202);
6120       var $204=$2;
6121       var $205=(($204+64)|0);
6122       var $206=HEAP32[(($205)>>2)];
6123       var $207=$st;
6124       var $208=(($207+2)|0);
6125       var $209=$208;
6126       var $210=HEAP16[(($209)>>1)];
6127       var $211=(($210)&65535);
6128       var $212=(($206+($211<<2))|0);
6129       var $213=$212;
6130       var $214=$213;
6131       var $215=(($214+8)|0);
6132       var $216=HEAPF32[(($215)>>2)];
6133       var $217=$2;
6134       var $218=(($217+64)|0);
6135       var $219=HEAP32[(($218)>>2)];
6136       var $220=$st;
6137       var $221=(($220+4)|0);
6138       var $222=$221;
6139       var $223=HEAP16[(($222)>>1)];
6140       var $224=(($223)&65535);
6141       var $225=(($219+($224<<2))|0);
6142       var $226=$225;
6143       var $227=$226;
6144       var $228=(($227+8)|0);
6145       var $229=HEAPF32[(($228)>>2)];
6146       var $230=($216)*($229);
6147       var $231=($203)+($230);
6148       var $232=$2;
6149       var $233=(($232+64)|0);
6150       var $234=HEAP32[(($233)>>2)];
6151       var $235=$st;
6152       var $236=(($235+6)|0);
6153       var $237=$236;
6154       var $238=HEAP16[(($237)>>1)];
6155       var $239=(($238)&65535);
6156       var $240=(($234+($239<<2))|0);
6157       var $241=$240;
6158       var $242=$241;
6159       HEAPF32[(($242)>>2)]=$231;
6160       __label__ = 124; break;
6161     case 12:
6162       var $244=$2;
6163       var $245=(($244+64)|0);
6164       var $246=HEAP32[(($245)>>2)];
6165       var $247=$st;
6166       var $248=(($247+2)|0);
6167       var $249=$248;
6168       var $250=HEAP16[(($249)>>1)];
6169       var $251=(($250)&65535);
6170       var $252=(($246+($251<<2))|0);
6171       var $253=$252;
6172       var $254=$253;
6173       var $255=HEAPF32[(($254)>>2)];
6174       var $256=$2;
6175       var $257=(($256+64)|0);
6176       var $258=HEAP32[(($257)>>2)];
6177       var $259=$st;
6178       var $260=(($259+4)|0);
6179       var $261=$260;
6180       var $262=HEAP16[(($261)>>1)];
6181       var $263=(($262)&65535);
6182       var $264=(($258+($263<<2))|0);
6183       var $265=$264;
6184       var $266=$265;
6185       var $267=(($266)|0);
6186       var $268=HEAPF32[(($267)>>2)];
6187       var $269=($255)*($268);
6188       var $270=$2;
6189       var $271=(($270+64)|0);
6190       var $272=HEAP32[(($271)>>2)];
6191       var $273=$st;
6192       var $274=(($273+6)|0);
6193       var $275=$274;
6194       var $276=HEAP16[(($275)>>1)];
6195       var $277=(($276)&65535);
6196       var $278=(($272+($277<<2))|0);
6197       var $279=$278;
6198       var $280=$279;
6199       var $281=(($280)|0);
6200       HEAPF32[(($281)>>2)]=$269;
6201       var $282=$2;
6202       var $283=(($282+64)|0);
6203       var $284=HEAP32[(($283)>>2)];
6204       var $285=$st;
6205       var $286=(($285+2)|0);
6206       var $287=$286;
6207       var $288=HEAP16[(($287)>>1)];
6208       var $289=(($288)&65535);
6209       var $290=(($284+($289<<2))|0);
6210       var $291=$290;
6211       var $292=$291;
6212       var $293=HEAPF32[(($292)>>2)];
6213       var $294=$2;
6214       var $295=(($294+64)|0);
6215       var $296=HEAP32[(($295)>>2)];
6216       var $297=$st;
6217       var $298=(($297+4)|0);
6218       var $299=$298;
6219       var $300=HEAP16[(($299)>>1)];
6220       var $301=(($300)&65535);
6221       var $302=(($296+($301<<2))|0);
6222       var $303=$302;
6223       var $304=$303;
6224       var $305=(($304+4)|0);
6225       var $306=HEAPF32[(($305)>>2)];
6226       var $307=($293)*($306);
6227       var $308=$2;
6228       var $309=(($308+64)|0);
6229       var $310=HEAP32[(($309)>>2)];
6230       var $311=$st;
6231       var $312=(($311+6)|0);
6232       var $313=$312;
6233       var $314=HEAP16[(($313)>>1)];
6234       var $315=(($314)&65535);
6235       var $316=(($310+($315<<2))|0);
6236       var $317=$316;
6237       var $318=$317;
6238       var $319=(($318+4)|0);
6239       HEAPF32[(($319)>>2)]=$307;
6240       var $320=$2;
6241       var $321=(($320+64)|0);
6242       var $322=HEAP32[(($321)>>2)];
6243       var $323=$st;
6244       var $324=(($323+2)|0);
6245       var $325=$324;
6246       var $326=HEAP16[(($325)>>1)];
6247       var $327=(($326)&65535);
6248       var $328=(($322+($327<<2))|0);
6249       var $329=$328;
6250       var $330=$329;
6251       var $331=HEAPF32[(($330)>>2)];
6252       var $332=$2;
6253       var $333=(($332+64)|0);
6254       var $334=HEAP32[(($333)>>2)];
6255       var $335=$st;
6256       var $336=(($335+4)|0);
6257       var $337=$336;
6258       var $338=HEAP16[(($337)>>1)];
6259       var $339=(($338)&65535);
6260       var $340=(($334+($339<<2))|0);
6261       var $341=$340;
6262       var $342=$341;
6263       var $343=(($342+8)|0);
6264       var $344=HEAPF32[(($343)>>2)];
6265       var $345=($331)*($344);
6266       var $346=$2;
6267       var $347=(($346+64)|0);
6268       var $348=HEAP32[(($347)>>2)];
6269       var $349=$st;
6270       var $350=(($349+6)|0);
6271       var $351=$350;
6272       var $352=HEAP16[(($351)>>1)];
6273       var $353=(($352)&65535);
6274       var $354=(($348+($353<<2))|0);
6275       var $355=$354;
6276       var $356=$355;
6277       var $357=(($356+8)|0);
6278       HEAPF32[(($357)>>2)]=$345;
6279       __label__ = 124; break;
6280     case 13:
6281       var $359=$2;
6282       var $360=(($359+64)|0);
6283       var $361=HEAP32[(($360)>>2)];
6284       var $362=$st;
6285       var $363=(($362+4)|0);
6286       var $364=$363;
6287       var $365=HEAP16[(($364)>>1)];
6288       var $366=(($365)&65535);
6289       var $367=(($361+($366<<2))|0);
6290       var $368=$367;
6291       var $369=$368;
6292       var $370=HEAPF32[(($369)>>2)];
6293       var $371=$2;
6294       var $372=(($371+64)|0);
6295       var $373=HEAP32[(($372)>>2)];
6296       var $374=$st;
6297       var $375=(($374+2)|0);
6298       var $376=$375;
6299       var $377=HEAP16[(($376)>>1)];
6300       var $378=(($377)&65535);
6301       var $379=(($373+($378<<2))|0);
6302       var $380=$379;
6303       var $381=$380;
6304       var $382=(($381)|0);
6305       var $383=HEAPF32[(($382)>>2)];
6306       var $384=($370)*($383);
6307       var $385=$2;
6308       var $386=(($385+64)|0);
6309       var $387=HEAP32[(($386)>>2)];
6310       var $388=$st;
6311       var $389=(($388+6)|0);
6312       var $390=$389;
6313       var $391=HEAP16[(($390)>>1)];
6314       var $392=(($391)&65535);
6315       var $393=(($387+($392<<2))|0);
6316       var $394=$393;
6317       var $395=$394;
6318       var $396=(($395)|0);
6319       HEAPF32[(($396)>>2)]=$384;
6320       var $397=$2;
6321       var $398=(($397+64)|0);
6322       var $399=HEAP32[(($398)>>2)];
6323       var $400=$st;
6324       var $401=(($400+4)|0);
6325       var $402=$401;
6326       var $403=HEAP16[(($402)>>1)];
6327       var $404=(($403)&65535);
6328       var $405=(($399+($404<<2))|0);
6329       var $406=$405;
6330       var $407=$406;
6331       var $408=HEAPF32[(($407)>>2)];
6332       var $409=$2;
6333       var $410=(($409+64)|0);
6334       var $411=HEAP32[(($410)>>2)];
6335       var $412=$st;
6336       var $413=(($412+2)|0);
6337       var $414=$413;
6338       var $415=HEAP16[(($414)>>1)];
6339       var $416=(($415)&65535);
6340       var $417=(($411+($416<<2))|0);
6341       var $418=$417;
6342       var $419=$418;
6343       var $420=(($419+4)|0);
6344       var $421=HEAPF32[(($420)>>2)];
6345       var $422=($408)*($421);
6346       var $423=$2;
6347       var $424=(($423+64)|0);
6348       var $425=HEAP32[(($424)>>2)];
6349       var $426=$st;
6350       var $427=(($426+6)|0);
6351       var $428=$427;
6352       var $429=HEAP16[(($428)>>1)];
6353       var $430=(($429)&65535);
6354       var $431=(($425+($430<<2))|0);
6355       var $432=$431;
6356       var $433=$432;
6357       var $434=(($433+4)|0);
6358       HEAPF32[(($434)>>2)]=$422;
6359       var $435=$2;
6360       var $436=(($435+64)|0);
6361       var $437=HEAP32[(($436)>>2)];
6362       var $438=$st;
6363       var $439=(($438+4)|0);
6364       var $440=$439;
6365       var $441=HEAP16[(($440)>>1)];
6366       var $442=(($441)&65535);
6367       var $443=(($437+($442<<2))|0);
6368       var $444=$443;
6369       var $445=$444;
6370       var $446=HEAPF32[(($445)>>2)];
6371       var $447=$2;
6372       var $448=(($447+64)|0);
6373       var $449=HEAP32[(($448)>>2)];
6374       var $450=$st;
6375       var $451=(($450+2)|0);
6376       var $452=$451;
6377       var $453=HEAP16[(($452)>>1)];
6378       var $454=(($453)&65535);
6379       var $455=(($449+($454<<2))|0);
6380       var $456=$455;
6381       var $457=$456;
6382       var $458=(($457+8)|0);
6383       var $459=HEAPF32[(($458)>>2)];
6384       var $460=($446)*($459);
6385       var $461=$2;
6386       var $462=(($461+64)|0);
6387       var $463=HEAP32[(($462)>>2)];
6388       var $464=$st;
6389       var $465=(($464+6)|0);
6390       var $466=$465;
6391       var $467=HEAP16[(($466)>>1)];
6392       var $468=(($467)&65535);
6393       var $469=(($463+($468<<2))|0);
6394       var $470=$469;
6395       var $471=$470;
6396       var $472=(($471+8)|0);
6397       HEAPF32[(($472)>>2)]=$460;
6398       __label__ = 124; break;
6399     case 14:
6400       var $474=$2;
6401       var $475=(($474+64)|0);
6402       var $476=HEAP32[(($475)>>2)];
6403       var $477=$st;
6404       var $478=(($477+4)|0);
6405       var $479=$478;
6406       var $480=HEAP16[(($479)>>1)];
6407       var $481=(($480)&65535);
6408       var $482=(($476+($481<<2))|0);
6409       var $483=$482;
6410       var $484=$483;
6411       var $485=HEAPF32[(($484)>>2)];
6412       var $486=$485 != 0;
6413       if ($486) { __label__ = 15; break; } else { __label__ = 16; break; }
6414     case 15:
6415       var $488=$2;
6416       var $489=(($488+64)|0);
6417       var $490=HEAP32[(($489)>>2)];
6418       var $491=$st;
6419       var $492=(($491+2)|0);
6420       var $493=$492;
6421       var $494=HEAP16[(($493)>>1)];
6422       var $495=(($494)&65535);
6423       var $496=(($490+($495<<2))|0);
6424       var $497=$496;
6425       var $498=$497;
6426       var $499=HEAPF32[(($498)>>2)];
6427       var $500=$2;
6428       var $501=(($500+64)|0);
6429       var $502=HEAP32[(($501)>>2)];
6430       var $503=$st;
6431       var $504=(($503+4)|0);
6432       var $505=$504;
6433       var $506=HEAP16[(($505)>>1)];
6434       var $507=(($506)&65535);
6435       var $508=(($502+($507<<2))|0);
6436       var $509=$508;
6437       var $510=$509;
6438       var $511=HEAPF32[(($510)>>2)];
6439       var $512=($499)/($511);
6440       var $513=$2;
6441       var $514=(($513+64)|0);
6442       var $515=HEAP32[(($514)>>2)];
6443       var $516=$st;
6444       var $517=(($516+6)|0);
6445       var $518=$517;
6446       var $519=HEAP16[(($518)>>1)];
6447       var $520=(($519)&65535);
6448       var $521=(($515+($520<<2))|0);
6449       var $522=$521;
6450       var $523=$522;
6451       HEAPF32[(($523)>>2)]=$512;
6452       __label__ = 17; break;
6453     case 16:
6454       var $525=$2;
6455       var $526=(($525+64)|0);
6456       var $527=HEAP32[(($526)>>2)];
6457       var $528=$st;
6458       var $529=(($528+6)|0);
6459       var $530=$529;
6460       var $531=HEAP16[(($530)>>1)];
6461       var $532=(($531)&65535);
6462       var $533=(($527+($532<<2))|0);
6463       var $534=$533;
6464       var $535=$534;
6465       HEAPF32[(($535)>>2)]=0;
6466       __label__ = 17; break;
6467     case 17:
6468       __label__ = 124; break;
6469     case 18:
6470       var $538=$2;
6471       var $539=(($538+64)|0);
6472       var $540=HEAP32[(($539)>>2)];
6473       var $541=$st;
6474       var $542=(($541+2)|0);
6475       var $543=$542;
6476       var $544=HEAP16[(($543)>>1)];
6477       var $545=(($544)&65535);
6478       var $546=(($540+($545<<2))|0);
6479       var $547=$546;
6480       var $548=$547;
6481       var $549=HEAPF32[(($548)>>2)];
6482       var $550=$2;
6483       var $551=(($550+64)|0);
6484       var $552=HEAP32[(($551)>>2)];
6485       var $553=$st;
6486       var $554=(($553+4)|0);
6487       var $555=$554;
6488       var $556=HEAP16[(($555)>>1)];
6489       var $557=(($556)&65535);
6490       var $558=(($552+($557<<2))|0);
6491       var $559=$558;
6492       var $560=$559;
6493       var $561=HEAPF32[(($560)>>2)];
6494       var $562=($549)+($561);
6495       var $563=$2;
6496       var $564=(($563+64)|0);
6497       var $565=HEAP32[(($564)>>2)];
6498       var $566=$st;
6499       var $567=(($566+6)|0);
6500       var $568=$567;
6501       var $569=HEAP16[(($568)>>1)];
6502       var $570=(($569)&65535);
6503       var $571=(($565+($570<<2))|0);
6504       var $572=$571;
6505       var $573=$572;
6506       HEAPF32[(($573)>>2)]=$562;
6507       __label__ = 124; break;
6508     case 19:
6509       var $575=$2;
6510       var $576=(($575+64)|0);
6511       var $577=HEAP32[(($576)>>2)];
6512       var $578=$st;
6513       var $579=(($578+2)|0);
6514       var $580=$579;
6515       var $581=HEAP16[(($580)>>1)];
6516       var $582=(($581)&65535);
6517       var $583=(($577+($582<<2))|0);
6518       var $584=$583;
6519       var $585=$584;
6520       var $586=(($585)|0);
6521       var $587=HEAPF32[(($586)>>2)];
6522       var $588=$2;
6523       var $589=(($588+64)|0);
6524       var $590=HEAP32[(($589)>>2)];
6525       var $591=$st;
6526       var $592=(($591+4)|0);
6527       var $593=$592;
6528       var $594=HEAP16[(($593)>>1)];
6529       var $595=(($594)&65535);
6530       var $596=(($590+($595<<2))|0);
6531       var $597=$596;
6532       var $598=$597;
6533       var $599=(($598)|0);
6534       var $600=HEAPF32[(($599)>>2)];
6535       var $601=($587)+($600);
6536       var $602=$2;
6537       var $603=(($602+64)|0);
6538       var $604=HEAP32[(($603)>>2)];
6539       var $605=$st;
6540       var $606=(($605+6)|0);
6541       var $607=$606;
6542       var $608=HEAP16[(($607)>>1)];
6543       var $609=(($608)&65535);
6544       var $610=(($604+($609<<2))|0);
6545       var $611=$610;
6546       var $612=$611;
6547       var $613=(($612)|0);
6548       HEAPF32[(($613)>>2)]=$601;
6549       var $614=$2;
6550       var $615=(($614+64)|0);
6551       var $616=HEAP32[(($615)>>2)];
6552       var $617=$st;
6553       var $618=(($617+2)|0);
6554       var $619=$618;
6555       var $620=HEAP16[(($619)>>1)];
6556       var $621=(($620)&65535);
6557       var $622=(($616+($621<<2))|0);
6558       var $623=$622;
6559       var $624=$623;
6560       var $625=(($624+4)|0);
6561       var $626=HEAPF32[(($625)>>2)];
6562       var $627=$2;
6563       var $628=(($627+64)|0);
6564       var $629=HEAP32[(($628)>>2)];
6565       var $630=$st;
6566       var $631=(($630+4)|0);
6567       var $632=$631;
6568       var $633=HEAP16[(($632)>>1)];
6569       var $634=(($633)&65535);
6570       var $635=(($629+($634<<2))|0);
6571       var $636=$635;
6572       var $637=$636;
6573       var $638=(($637+4)|0);
6574       var $639=HEAPF32[(($638)>>2)];
6575       var $640=($626)+($639);
6576       var $641=$2;
6577       var $642=(($641+64)|0);
6578       var $643=HEAP32[(($642)>>2)];
6579       var $644=$st;
6580       var $645=(($644+6)|0);
6581       var $646=$645;
6582       var $647=HEAP16[(($646)>>1)];
6583       var $648=(($647)&65535);
6584       var $649=(($643+($648<<2))|0);
6585       var $650=$649;
6586       var $651=$650;
6587       var $652=(($651+4)|0);
6588       HEAPF32[(($652)>>2)]=$640;
6589       var $653=$2;
6590       var $654=(($653+64)|0);
6591       var $655=HEAP32[(($654)>>2)];
6592       var $656=$st;
6593       var $657=(($656+2)|0);
6594       var $658=$657;
6595       var $659=HEAP16[(($658)>>1)];
6596       var $660=(($659)&65535);
6597       var $661=(($655+($660<<2))|0);
6598       var $662=$661;
6599       var $663=$662;
6600       var $664=(($663+8)|0);
6601       var $665=HEAPF32[(($664)>>2)];
6602       var $666=$2;
6603       var $667=(($666+64)|0);
6604       var $668=HEAP32[(($667)>>2)];
6605       var $669=$st;
6606       var $670=(($669+4)|0);
6607       var $671=$670;
6608       var $672=HEAP16[(($671)>>1)];
6609       var $673=(($672)&65535);
6610       var $674=(($668+($673<<2))|0);
6611       var $675=$674;
6612       var $676=$675;
6613       var $677=(($676+8)|0);
6614       var $678=HEAPF32[(($677)>>2)];
6615       var $679=($665)+($678);
6616       var $680=$2;
6617       var $681=(($680+64)|0);
6618       var $682=HEAP32[(($681)>>2)];
6619       var $683=$st;
6620       var $684=(($683+6)|0);
6621       var $685=$684;
6622       var $686=HEAP16[(($685)>>1)];
6623       var $687=(($686)&65535);
6624       var $688=(($682+($687<<2))|0);
6625       var $689=$688;
6626       var $690=$689;
6627       var $691=(($690+8)|0);
6628       HEAPF32[(($691)>>2)]=$679;
6629       __label__ = 124; break;
6630     case 20:
6631       var $693=$2;
6632       var $694=(($693+64)|0);
6633       var $695=HEAP32[(($694)>>2)];
6634       var $696=$st;
6635       var $697=(($696+2)|0);
6636       var $698=$697;
6637       var $699=HEAP16[(($698)>>1)];
6638       var $700=(($699)&65535);
6639       var $701=(($695+($700<<2))|0);
6640       var $702=$701;
6641       var $703=$702;
6642       var $704=HEAPF32[(($703)>>2)];
6643       var $705=$2;
6644       var $706=(($705+64)|0);
6645       var $707=HEAP32[(($706)>>2)];
6646       var $708=$st;
6647       var $709=(($708+4)|0);
6648       var $710=$709;
6649       var $711=HEAP16[(($710)>>1)];
6650       var $712=(($711)&65535);
6651       var $713=(($707+($712<<2))|0);
6652       var $714=$713;
6653       var $715=$714;
6654       var $716=HEAPF32[(($715)>>2)];
6655       var $717=($704)-($716);
6656       var $718=$2;
6657       var $719=(($718+64)|0);
6658       var $720=HEAP32[(($719)>>2)];
6659       var $721=$st;
6660       var $722=(($721+6)|0);
6661       var $723=$722;
6662       var $724=HEAP16[(($723)>>1)];
6663       var $725=(($724)&65535);
6664       var $726=(($720+($725<<2))|0);
6665       var $727=$726;
6666       var $728=$727;
6667       HEAPF32[(($728)>>2)]=$717;
6668       __label__ = 124; break;
6669     case 21:
6670       var $730=$2;
6671       var $731=(($730+64)|0);
6672       var $732=HEAP32[(($731)>>2)];
6673       var $733=$st;
6674       var $734=(($733+2)|0);
6675       var $735=$734;
6676       var $736=HEAP16[(($735)>>1)];
6677       var $737=(($736)&65535);
6678       var $738=(($732+($737<<2))|0);
6679       var $739=$738;
6680       var $740=$739;
6681       var $741=(($740)|0);
6682       var $742=HEAPF32[(($741)>>2)];
6683       var $743=$2;
6684       var $744=(($743+64)|0);
6685       var $745=HEAP32[(($744)>>2)];
6686       var $746=$st;
6687       var $747=(($746+4)|0);
6688       var $748=$747;
6689       var $749=HEAP16[(($748)>>1)];
6690       var $750=(($749)&65535);
6691       var $751=(($745+($750<<2))|0);
6692       var $752=$751;
6693       var $753=$752;
6694       var $754=(($753)|0);
6695       var $755=HEAPF32[(($754)>>2)];
6696       var $756=($742)-($755);
6697       var $757=$2;
6698       var $758=(($757+64)|0);
6699       var $759=HEAP32[(($758)>>2)];
6700       var $760=$st;
6701       var $761=(($760+6)|0);
6702       var $762=$761;
6703       var $763=HEAP16[(($762)>>1)];
6704       var $764=(($763)&65535);
6705       var $765=(($759+($764<<2))|0);
6706       var $766=$765;
6707       var $767=$766;
6708       var $768=(($767)|0);
6709       HEAPF32[(($768)>>2)]=$756;
6710       var $769=$2;
6711       var $770=(($769+64)|0);
6712       var $771=HEAP32[(($770)>>2)];
6713       var $772=$st;
6714       var $773=(($772+2)|0);
6715       var $774=$773;
6716       var $775=HEAP16[(($774)>>1)];
6717       var $776=(($775)&65535);
6718       var $777=(($771+($776<<2))|0);
6719       var $778=$777;
6720       var $779=$778;
6721       var $780=(($779+4)|0);
6722       var $781=HEAPF32[(($780)>>2)];
6723       var $782=$2;
6724       var $783=(($782+64)|0);
6725       var $784=HEAP32[(($783)>>2)];
6726       var $785=$st;
6727       var $786=(($785+4)|0);
6728       var $787=$786;
6729       var $788=HEAP16[(($787)>>1)];
6730       var $789=(($788)&65535);
6731       var $790=(($784+($789<<2))|0);
6732       var $791=$790;
6733       var $792=$791;
6734       var $793=(($792+4)|0);
6735       var $794=HEAPF32[(($793)>>2)];
6736       var $795=($781)-($794);
6737       var $796=$2;
6738       var $797=(($796+64)|0);
6739       var $798=HEAP32[(($797)>>2)];
6740       var $799=$st;
6741       var $800=(($799+6)|0);
6742       var $801=$800;
6743       var $802=HEAP16[(($801)>>1)];
6744       var $803=(($802)&65535);
6745       var $804=(($798+($803<<2))|0);
6746       var $805=$804;
6747       var $806=$805;
6748       var $807=(($806+4)|0);
6749       HEAPF32[(($807)>>2)]=$795;
6750       var $808=$2;
6751       var $809=(($808+64)|0);
6752       var $810=HEAP32[(($809)>>2)];
6753       var $811=$st;
6754       var $812=(($811+2)|0);
6755       var $813=$812;
6756       var $814=HEAP16[(($813)>>1)];
6757       var $815=(($814)&65535);
6758       var $816=(($810+($815<<2))|0);
6759       var $817=$816;
6760       var $818=$817;
6761       var $819=(($818+8)|0);
6762       var $820=HEAPF32[(($819)>>2)];
6763       var $821=$2;
6764       var $822=(($821+64)|0);
6765       var $823=HEAP32[(($822)>>2)];
6766       var $824=$st;
6767       var $825=(($824+4)|0);
6768       var $826=$825;
6769       var $827=HEAP16[(($826)>>1)];
6770       var $828=(($827)&65535);
6771       var $829=(($823+($828<<2))|0);
6772       var $830=$829;
6773       var $831=$830;
6774       var $832=(($831+8)|0);
6775       var $833=HEAPF32[(($832)>>2)];
6776       var $834=($820)-($833);
6777       var $835=$2;
6778       var $836=(($835+64)|0);
6779       var $837=HEAP32[(($836)>>2)];
6780       var $838=$st;
6781       var $839=(($838+6)|0);
6782       var $840=$839;
6783       var $841=HEAP16[(($840)>>1)];
6784       var $842=(($841)&65535);
6785       var $843=(($837+($842<<2))|0);
6786       var $844=$843;
6787       var $845=$844;
6788       var $846=(($845+8)|0);
6789       HEAPF32[(($846)>>2)]=$834;
6790       __label__ = 124; break;
6791     case 22:
6792       var $848=$2;
6793       var $849=(($848+64)|0);
6794       var $850=HEAP32[(($849)>>2)];
6795       var $851=$st;
6796       var $852=(($851+2)|0);
6797       var $853=$852;
6798       var $854=HEAP16[(($853)>>1)];
6799       var $855=(($854)&65535);
6800       var $856=(($850+($855<<2))|0);
6801       var $857=$856;
6802       var $858=$857;
6803       var $859=HEAPF32[(($858)>>2)];
6804       var $860=$2;
6805       var $861=(($860+64)|0);
6806       var $862=HEAP32[(($861)>>2)];
6807       var $863=$st;
6808       var $864=(($863+4)|0);
6809       var $865=$864;
6810       var $866=HEAP16[(($865)>>1)];
6811       var $867=(($866)&65535);
6812       var $868=(($862+($867<<2))|0);
6813       var $869=$868;
6814       var $870=$869;
6815       var $871=HEAPF32[(($870)>>2)];
6816       var $872=$859 == $871;
6817       var $873=(($872)&1);
6818       var $874=(($873)|0);
6819       var $875=$2;
6820       var $876=(($875+64)|0);
6821       var $877=HEAP32[(($876)>>2)];
6822       var $878=$st;
6823       var $879=(($878+6)|0);
6824       var $880=$879;
6825       var $881=HEAP16[(($880)>>1)];
6826       var $882=(($881)&65535);
6827       var $883=(($877+($882<<2))|0);
6828       var $884=$883;
6829       var $885=$884;
6830       HEAPF32[(($885)>>2)]=$874;
6831       __label__ = 124; break;
6832     case 23:
6833       var $887=$2;
6834       var $888=(($887+64)|0);
6835       var $889=HEAP32[(($888)>>2)];
6836       var $890=$st;
6837       var $891=(($890+2)|0);
6838       var $892=$891;
6839       var $893=HEAP16[(($892)>>1)];
6840       var $894=(($893)&65535);
6841       var $895=(($889+($894<<2))|0);
6842       var $896=$895;
6843       var $897=$896;
6844       var $898=(($897)|0);
6845       var $899=HEAPF32[(($898)>>2)];
6846       var $900=$2;
6847       var $901=(($900+64)|0);
6848       var $902=HEAP32[(($901)>>2)];
6849       var $903=$st;
6850       var $904=(($903+4)|0);
6851       var $905=$904;
6852       var $906=HEAP16[(($905)>>1)];
6853       var $907=(($906)&65535);
6854       var $908=(($902+($907<<2))|0);
6855       var $909=$908;
6856       var $910=$909;
6857       var $911=(($910)|0);
6858       var $912=HEAPF32[(($911)>>2)];
6859       var $913=$899 == $912;
6860       if ($913) { __label__ = 24; break; } else { var $971 = 0;__label__ = 26; break; }
6861     case 24:
6862       var $915=$2;
6863       var $916=(($915+64)|0);
6864       var $917=HEAP32[(($916)>>2)];
6865       var $918=$st;
6866       var $919=(($918+2)|0);
6867       var $920=$919;
6868       var $921=HEAP16[(($920)>>1)];
6869       var $922=(($921)&65535);
6870       var $923=(($917+($922<<2))|0);
6871       var $924=$923;
6872       var $925=$924;
6873       var $926=(($925+4)|0);
6874       var $927=HEAPF32[(($926)>>2)];
6875       var $928=$2;
6876       var $929=(($928+64)|0);
6877       var $930=HEAP32[(($929)>>2)];
6878       var $931=$st;
6879       var $932=(($931+4)|0);
6880       var $933=$932;
6881       var $934=HEAP16[(($933)>>1)];
6882       var $935=(($934)&65535);
6883       var $936=(($930+($935<<2))|0);
6884       var $937=$936;
6885       var $938=$937;
6886       var $939=(($938+4)|0);
6887       var $940=HEAPF32[(($939)>>2)];
6888       var $941=$927 == $940;
6889       if ($941) { __label__ = 25; break; } else { var $971 = 0;__label__ = 26; break; }
6890     case 25:
6891       var $943=$2;
6892       var $944=(($943+64)|0);
6893       var $945=HEAP32[(($944)>>2)];
6894       var $946=$st;
6895       var $947=(($946+2)|0);
6896       var $948=$947;
6897       var $949=HEAP16[(($948)>>1)];
6898       var $950=(($949)&65535);
6899       var $951=(($945+($950<<2))|0);
6900       var $952=$951;
6901       var $953=$952;
6902       var $954=(($953+8)|0);
6903       var $955=HEAPF32[(($954)>>2)];
6904       var $956=$2;
6905       var $957=(($956+64)|0);
6906       var $958=HEAP32[(($957)>>2)];
6907       var $959=$st;
6908       var $960=(($959+4)|0);
6909       var $961=$960;
6910       var $962=HEAP16[(($961)>>1)];
6911       var $963=(($962)&65535);
6912       var $964=(($958+($963<<2))|0);
6913       var $965=$964;
6914       var $966=$965;
6915       var $967=(($966+8)|0);
6916       var $968=HEAPF32[(($967)>>2)];
6917       var $969=$955 == $968;
6918       var $971 = $969;__label__ = 26; break;
6919     case 26:
6920       var $971;
6921       var $972=(($971)&1);
6922       var $973=(($972)|0);
6923       var $974=$2;
6924       var $975=(($974+64)|0);
6925       var $976=HEAP32[(($975)>>2)];
6926       var $977=$st;
6927       var $978=(($977+6)|0);
6928       var $979=$978;
6929       var $980=HEAP16[(($979)>>1)];
6930       var $981=(($980)&65535);
6931       var $982=(($976+($981<<2))|0);
6932       var $983=$982;
6933       var $984=$983;
6934       HEAPF32[(($984)>>2)]=$973;
6935       __label__ = 124; break;
6936     case 27:
6937       var $986=$2;
6938       var $987=$2;
6939       var $988=(($987+64)|0);
6940       var $989=HEAP32[(($988)>>2)];
6941       var $990=$st;
6942       var $991=(($990+2)|0);
6943       var $992=$991;
6944       var $993=HEAP16[(($992)>>1)];
6945       var $994=(($993)&65535);
6946       var $995=(($989+($994<<2))|0);
6947       var $996=$995;
6948       var $997=$996;
6949       var $998=HEAP32[(($997)>>2)];
6950       var $999=_prog_getstring($986, $998);
6951       var $1000=$2;
6952       var $1001=$2;
6953       var $1002=(($1001+64)|0);
6954       var $1003=HEAP32[(($1002)>>2)];
6955       var $1004=$st;
6956       var $1005=(($1004+4)|0);
6957       var $1006=$1005;
6958       var $1007=HEAP16[(($1006)>>1)];
6959       var $1008=(($1007)&65535);
6960       var $1009=(($1003+($1008<<2))|0);
6961       var $1010=$1009;
6962       var $1011=$1010;
6963       var $1012=HEAP32[(($1011)>>2)];
6964       var $1013=_prog_getstring($1000, $1012);
6965       var $1014=_strcmp($999, $1013);
6966       var $1015=(($1014)|0)!=0;
6967       var $1016=$1015 ^ 1;
6968       var $1017=(($1016)&1);
6969       var $1018=(($1017)|0);
6970       var $1019=$2;
6971       var $1020=(($1019+64)|0);
6972       var $1021=HEAP32[(($1020)>>2)];
6973       var $1022=$st;
6974       var $1023=(($1022+6)|0);
6975       var $1024=$1023;
6976       var $1025=HEAP16[(($1024)>>1)];
6977       var $1026=(($1025)&65535);
6978       var $1027=(($1021+($1026<<2))|0);
6979       var $1028=$1027;
6980       var $1029=$1028;
6981       HEAPF32[(($1029)>>2)]=$1018;
6982       __label__ = 124; break;
6983     case 28:
6984       var $1031=$2;
6985       var $1032=(($1031+64)|0);
6986       var $1033=HEAP32[(($1032)>>2)];
6987       var $1034=$st;
6988       var $1035=(($1034+2)|0);
6989       var $1036=$1035;
6990       var $1037=HEAP16[(($1036)>>1)];
6991       var $1038=(($1037)&65535);
6992       var $1039=(($1033+($1038<<2))|0);
6993       var $1040=$1039;
6994       var $1041=$1040;
6995       var $1042=HEAP32[(($1041)>>2)];
6996       var $1043=$2;
6997       var $1044=(($1043+64)|0);
6998       var $1045=HEAP32[(($1044)>>2)];
6999       var $1046=$st;
7000       var $1047=(($1046+4)|0);
7001       var $1048=$1047;
7002       var $1049=HEAP16[(($1048)>>1)];
7003       var $1050=(($1049)&65535);
7004       var $1051=(($1045+($1050<<2))|0);
7005       var $1052=$1051;
7006       var $1053=$1052;
7007       var $1054=HEAP32[(($1053)>>2)];
7008       var $1055=(($1042)|0)==(($1054)|0);
7009       var $1056=(($1055)&1);
7010       var $1057=(($1056)|0);
7011       var $1058=$2;
7012       var $1059=(($1058+64)|0);
7013       var $1060=HEAP32[(($1059)>>2)];
7014       var $1061=$st;
7015       var $1062=(($1061+6)|0);
7016       var $1063=$1062;
7017       var $1064=HEAP16[(($1063)>>1)];
7018       var $1065=(($1064)&65535);
7019       var $1066=(($1060+($1065<<2))|0);
7020       var $1067=$1066;
7021       var $1068=$1067;
7022       HEAPF32[(($1068)>>2)]=$1057;
7023       __label__ = 124; break;
7024     case 29:
7025       var $1070=$2;
7026       var $1071=(($1070+64)|0);
7027       var $1072=HEAP32[(($1071)>>2)];
7028       var $1073=$st;
7029       var $1074=(($1073+2)|0);
7030       var $1075=$1074;
7031       var $1076=HEAP16[(($1075)>>1)];
7032       var $1077=(($1076)&65535);
7033       var $1078=(($1072+($1077<<2))|0);
7034       var $1079=$1078;
7035       var $1080=$1079;
7036       var $1081=HEAP32[(($1080)>>2)];
7037       var $1082=$2;
7038       var $1083=(($1082+64)|0);
7039       var $1084=HEAP32[(($1083)>>2)];
7040       var $1085=$st;
7041       var $1086=(($1085+4)|0);
7042       var $1087=$1086;
7043       var $1088=HEAP16[(($1087)>>1)];
7044       var $1089=(($1088)&65535);
7045       var $1090=(($1084+($1089<<2))|0);
7046       var $1091=$1090;
7047       var $1092=$1091;
7048       var $1093=HEAP32[(($1092)>>2)];
7049       var $1094=(($1081)|0)==(($1093)|0);
7050       var $1095=(($1094)&1);
7051       var $1096=(($1095)|0);
7052       var $1097=$2;
7053       var $1098=(($1097+64)|0);
7054       var $1099=HEAP32[(($1098)>>2)];
7055       var $1100=$st;
7056       var $1101=(($1100+6)|0);
7057       var $1102=$1101;
7058       var $1103=HEAP16[(($1102)>>1)];
7059       var $1104=(($1103)&65535);
7060       var $1105=(($1099+($1104<<2))|0);
7061       var $1106=$1105;
7062       var $1107=$1106;
7063       HEAPF32[(($1107)>>2)]=$1096;
7064       __label__ = 124; break;
7065     case 30:
7066       var $1109=$2;
7067       var $1110=(($1109+64)|0);
7068       var $1111=HEAP32[(($1110)>>2)];
7069       var $1112=$st;
7070       var $1113=(($1112+2)|0);
7071       var $1114=$1113;
7072       var $1115=HEAP16[(($1114)>>1)];
7073       var $1116=(($1115)&65535);
7074       var $1117=(($1111+($1116<<2))|0);
7075       var $1118=$1117;
7076       var $1119=$1118;
7077       var $1120=HEAPF32[(($1119)>>2)];
7078       var $1121=$2;
7079       var $1122=(($1121+64)|0);
7080       var $1123=HEAP32[(($1122)>>2)];
7081       var $1124=$st;
7082       var $1125=(($1124+4)|0);
7083       var $1126=$1125;
7084       var $1127=HEAP16[(($1126)>>1)];
7085       var $1128=(($1127)&65535);
7086       var $1129=(($1123+($1128<<2))|0);
7087       var $1130=$1129;
7088       var $1131=$1130;
7089       var $1132=HEAPF32[(($1131)>>2)];
7090       var $1133=$1120 != $1132;
7091       var $1134=(($1133)&1);
7092       var $1135=(($1134)|0);
7093       var $1136=$2;
7094       var $1137=(($1136+64)|0);
7095       var $1138=HEAP32[(($1137)>>2)];
7096       var $1139=$st;
7097       var $1140=(($1139+6)|0);
7098       var $1141=$1140;
7099       var $1142=HEAP16[(($1141)>>1)];
7100       var $1143=(($1142)&65535);
7101       var $1144=(($1138+($1143<<2))|0);
7102       var $1145=$1144;
7103       var $1146=$1145;
7104       HEAPF32[(($1146)>>2)]=$1135;
7105       __label__ = 124; break;
7106     case 31:
7107       var $1148=$2;
7108       var $1149=(($1148+64)|0);
7109       var $1150=HEAP32[(($1149)>>2)];
7110       var $1151=$st;
7111       var $1152=(($1151+2)|0);
7112       var $1153=$1152;
7113       var $1154=HEAP16[(($1153)>>1)];
7114       var $1155=(($1154)&65535);
7115       var $1156=(($1150+($1155<<2))|0);
7116       var $1157=$1156;
7117       var $1158=$1157;
7118       var $1159=(($1158)|0);
7119       var $1160=HEAPF32[(($1159)>>2)];
7120       var $1161=$2;
7121       var $1162=(($1161+64)|0);
7122       var $1163=HEAP32[(($1162)>>2)];
7123       var $1164=$st;
7124       var $1165=(($1164+4)|0);
7125       var $1166=$1165;
7126       var $1167=HEAP16[(($1166)>>1)];
7127       var $1168=(($1167)&65535);
7128       var $1169=(($1163+($1168<<2))|0);
7129       var $1170=$1169;
7130       var $1171=$1170;
7131       var $1172=(($1171)|0);
7132       var $1173=HEAPF32[(($1172)>>2)];
7133       var $1174=$1160 != $1173;
7134       if ($1174) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 32; break; }
7135     case 32:
7136       var $1176=$2;
7137       var $1177=(($1176+64)|0);
7138       var $1178=HEAP32[(($1177)>>2)];
7139       var $1179=$st;
7140       var $1180=(($1179+2)|0);
7141       var $1181=$1180;
7142       var $1182=HEAP16[(($1181)>>1)];
7143       var $1183=(($1182)&65535);
7144       var $1184=(($1178+($1183<<2))|0);
7145       var $1185=$1184;
7146       var $1186=$1185;
7147       var $1187=(($1186+4)|0);
7148       var $1188=HEAPF32[(($1187)>>2)];
7149       var $1189=$2;
7150       var $1190=(($1189+64)|0);
7151       var $1191=HEAP32[(($1190)>>2)];
7152       var $1192=$st;
7153       var $1193=(($1192+4)|0);
7154       var $1194=$1193;
7155       var $1195=HEAP16[(($1194)>>1)];
7156       var $1196=(($1195)&65535);
7157       var $1197=(($1191+($1196<<2))|0);
7158       var $1198=$1197;
7159       var $1199=$1198;
7160       var $1200=(($1199+4)|0);
7161       var $1201=HEAPF32[(($1200)>>2)];
7162       var $1202=$1188 != $1201;
7163       if ($1202) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 33; break; }
7164     case 33:
7165       var $1204=$2;
7166       var $1205=(($1204+64)|0);
7167       var $1206=HEAP32[(($1205)>>2)];
7168       var $1207=$st;
7169       var $1208=(($1207+2)|0);
7170       var $1209=$1208;
7171       var $1210=HEAP16[(($1209)>>1)];
7172       var $1211=(($1210)&65535);
7173       var $1212=(($1206+($1211<<2))|0);
7174       var $1213=$1212;
7175       var $1214=$1213;
7176       var $1215=(($1214+8)|0);
7177       var $1216=HEAPF32[(($1215)>>2)];
7178       var $1217=$2;
7179       var $1218=(($1217+64)|0);
7180       var $1219=HEAP32[(($1218)>>2)];
7181       var $1220=$st;
7182       var $1221=(($1220+4)|0);
7183       var $1222=$1221;
7184       var $1223=HEAP16[(($1222)>>1)];
7185       var $1224=(($1223)&65535);
7186       var $1225=(($1219+($1224<<2))|0);
7187       var $1226=$1225;
7188       var $1227=$1226;
7189       var $1228=(($1227+8)|0);
7190       var $1229=HEAPF32[(($1228)>>2)];
7191       var $1230=$1216 != $1229;
7192       var $1232 = $1230;__label__ = 34; break;
7193     case 34:
7194       var $1232;
7195       var $1233=(($1232)&1);
7196       var $1234=(($1233)|0);
7197       var $1235=$2;
7198       var $1236=(($1235+64)|0);
7199       var $1237=HEAP32[(($1236)>>2)];
7200       var $1238=$st;
7201       var $1239=(($1238+6)|0);
7202       var $1240=$1239;
7203       var $1241=HEAP16[(($1240)>>1)];
7204       var $1242=(($1241)&65535);
7205       var $1243=(($1237+($1242<<2))|0);
7206       var $1244=$1243;
7207       var $1245=$1244;
7208       HEAPF32[(($1245)>>2)]=$1234;
7209       __label__ = 124; break;
7210     case 35:
7211       var $1247=$2;
7212       var $1248=$2;
7213       var $1249=(($1248+64)|0);
7214       var $1250=HEAP32[(($1249)>>2)];
7215       var $1251=$st;
7216       var $1252=(($1251+2)|0);
7217       var $1253=$1252;
7218       var $1254=HEAP16[(($1253)>>1)];
7219       var $1255=(($1254)&65535);
7220       var $1256=(($1250+($1255<<2))|0);
7221       var $1257=$1256;
7222       var $1258=$1257;
7223       var $1259=HEAP32[(($1258)>>2)];
7224       var $1260=_prog_getstring($1247, $1259);
7225       var $1261=$2;
7226       var $1262=$2;
7227       var $1263=(($1262+64)|0);
7228       var $1264=HEAP32[(($1263)>>2)];
7229       var $1265=$st;
7230       var $1266=(($1265+4)|0);
7231       var $1267=$1266;
7232       var $1268=HEAP16[(($1267)>>1)];
7233       var $1269=(($1268)&65535);
7234       var $1270=(($1264+($1269<<2))|0);
7235       var $1271=$1270;
7236       var $1272=$1271;
7237       var $1273=HEAP32[(($1272)>>2)];
7238       var $1274=_prog_getstring($1261, $1273);
7239       var $1275=_strcmp($1260, $1274);
7240       var $1276=(($1275)|0)!=0;
7241       var $1277=$1276 ^ 1;
7242       var $1278=$1277 ^ 1;
7243       var $1279=(($1278)&1);
7244       var $1280=(($1279)|0);
7245       var $1281=$2;
7246       var $1282=(($1281+64)|0);
7247       var $1283=HEAP32[(($1282)>>2)];
7248       var $1284=$st;
7249       var $1285=(($1284+6)|0);
7250       var $1286=$1285;
7251       var $1287=HEAP16[(($1286)>>1)];
7252       var $1288=(($1287)&65535);
7253       var $1289=(($1283+($1288<<2))|0);
7254       var $1290=$1289;
7255       var $1291=$1290;
7256       HEAPF32[(($1291)>>2)]=$1280;
7257       __label__ = 124; break;
7258     case 36:
7259       var $1293=$2;
7260       var $1294=(($1293+64)|0);
7261       var $1295=HEAP32[(($1294)>>2)];
7262       var $1296=$st;
7263       var $1297=(($1296+2)|0);
7264       var $1298=$1297;
7265       var $1299=HEAP16[(($1298)>>1)];
7266       var $1300=(($1299)&65535);
7267       var $1301=(($1295+($1300<<2))|0);
7268       var $1302=$1301;
7269       var $1303=$1302;
7270       var $1304=HEAP32[(($1303)>>2)];
7271       var $1305=$2;
7272       var $1306=(($1305+64)|0);
7273       var $1307=HEAP32[(($1306)>>2)];
7274       var $1308=$st;
7275       var $1309=(($1308+4)|0);
7276       var $1310=$1309;
7277       var $1311=HEAP16[(($1310)>>1)];
7278       var $1312=(($1311)&65535);
7279       var $1313=(($1307+($1312<<2))|0);
7280       var $1314=$1313;
7281       var $1315=$1314;
7282       var $1316=HEAP32[(($1315)>>2)];
7283       var $1317=(($1304)|0)!=(($1316)|0);
7284       var $1318=(($1317)&1);
7285       var $1319=(($1318)|0);
7286       var $1320=$2;
7287       var $1321=(($1320+64)|0);
7288       var $1322=HEAP32[(($1321)>>2)];
7289       var $1323=$st;
7290       var $1324=(($1323+6)|0);
7291       var $1325=$1324;
7292       var $1326=HEAP16[(($1325)>>1)];
7293       var $1327=(($1326)&65535);
7294       var $1328=(($1322+($1327<<2))|0);
7295       var $1329=$1328;
7296       var $1330=$1329;
7297       HEAPF32[(($1330)>>2)]=$1319;
7298       __label__ = 124; break;
7299     case 37:
7300       var $1332=$2;
7301       var $1333=(($1332+64)|0);
7302       var $1334=HEAP32[(($1333)>>2)];
7303       var $1335=$st;
7304       var $1336=(($1335+2)|0);
7305       var $1337=$1336;
7306       var $1338=HEAP16[(($1337)>>1)];
7307       var $1339=(($1338)&65535);
7308       var $1340=(($1334+($1339<<2))|0);
7309       var $1341=$1340;
7310       var $1342=$1341;
7311       var $1343=HEAP32[(($1342)>>2)];
7312       var $1344=$2;
7313       var $1345=(($1344+64)|0);
7314       var $1346=HEAP32[(($1345)>>2)];
7315       var $1347=$st;
7316       var $1348=(($1347+4)|0);
7317       var $1349=$1348;
7318       var $1350=HEAP16[(($1349)>>1)];
7319       var $1351=(($1350)&65535);
7320       var $1352=(($1346+($1351<<2))|0);
7321       var $1353=$1352;
7322       var $1354=$1353;
7323       var $1355=HEAP32[(($1354)>>2)];
7324       var $1356=(($1343)|0)!=(($1355)|0);
7325       var $1357=(($1356)&1);
7326       var $1358=(($1357)|0);
7327       var $1359=$2;
7328       var $1360=(($1359+64)|0);
7329       var $1361=HEAP32[(($1360)>>2)];
7330       var $1362=$st;
7331       var $1363=(($1362+6)|0);
7332       var $1364=$1363;
7333       var $1365=HEAP16[(($1364)>>1)];
7334       var $1366=(($1365)&65535);
7335       var $1367=(($1361+($1366<<2))|0);
7336       var $1368=$1367;
7337       var $1369=$1368;
7338       HEAPF32[(($1369)>>2)]=$1358;
7339       __label__ = 124; break;
7340     case 38:
7341       var $1371=$2;
7342       var $1372=(($1371+64)|0);
7343       var $1373=HEAP32[(($1372)>>2)];
7344       var $1374=$st;
7345       var $1375=(($1374+2)|0);
7346       var $1376=$1375;
7347       var $1377=HEAP16[(($1376)>>1)];
7348       var $1378=(($1377)&65535);
7349       var $1379=(($1373+($1378<<2))|0);
7350       var $1380=$1379;
7351       var $1381=$1380;
7352       var $1382=HEAPF32[(($1381)>>2)];
7353       var $1383=$2;
7354       var $1384=(($1383+64)|0);
7355       var $1385=HEAP32[(($1384)>>2)];
7356       var $1386=$st;
7357       var $1387=(($1386+4)|0);
7358       var $1388=$1387;
7359       var $1389=HEAP16[(($1388)>>1)];
7360       var $1390=(($1389)&65535);
7361       var $1391=(($1385+($1390<<2))|0);
7362       var $1392=$1391;
7363       var $1393=$1392;
7364       var $1394=HEAPF32[(($1393)>>2)];
7365       var $1395=$1382 <= $1394;
7366       var $1396=(($1395)&1);
7367       var $1397=(($1396)|0);
7368       var $1398=$2;
7369       var $1399=(($1398+64)|0);
7370       var $1400=HEAP32[(($1399)>>2)];
7371       var $1401=$st;
7372       var $1402=(($1401+6)|0);
7373       var $1403=$1402;
7374       var $1404=HEAP16[(($1403)>>1)];
7375       var $1405=(($1404)&65535);
7376       var $1406=(($1400+($1405<<2))|0);
7377       var $1407=$1406;
7378       var $1408=$1407;
7379       HEAPF32[(($1408)>>2)]=$1397;
7380       __label__ = 124; break;
7381     case 39:
7382       var $1410=$2;
7383       var $1411=(($1410+64)|0);
7384       var $1412=HEAP32[(($1411)>>2)];
7385       var $1413=$st;
7386       var $1414=(($1413+2)|0);
7387       var $1415=$1414;
7388       var $1416=HEAP16[(($1415)>>1)];
7389       var $1417=(($1416)&65535);
7390       var $1418=(($1412+($1417<<2))|0);
7391       var $1419=$1418;
7392       var $1420=$1419;
7393       var $1421=HEAPF32[(($1420)>>2)];
7394       var $1422=$2;
7395       var $1423=(($1422+64)|0);
7396       var $1424=HEAP32[(($1423)>>2)];
7397       var $1425=$st;
7398       var $1426=(($1425+4)|0);
7399       var $1427=$1426;
7400       var $1428=HEAP16[(($1427)>>1)];
7401       var $1429=(($1428)&65535);
7402       var $1430=(($1424+($1429<<2))|0);
7403       var $1431=$1430;
7404       var $1432=$1431;
7405       var $1433=HEAPF32[(($1432)>>2)];
7406       var $1434=$1421 >= $1433;
7407       var $1435=(($1434)&1);
7408       var $1436=(($1435)|0);
7409       var $1437=$2;
7410       var $1438=(($1437+64)|0);
7411       var $1439=HEAP32[(($1438)>>2)];
7412       var $1440=$st;
7413       var $1441=(($1440+6)|0);
7414       var $1442=$1441;
7415       var $1443=HEAP16[(($1442)>>1)];
7416       var $1444=(($1443)&65535);
7417       var $1445=(($1439+($1444<<2))|0);
7418       var $1446=$1445;
7419       var $1447=$1446;
7420       HEAPF32[(($1447)>>2)]=$1436;
7421       __label__ = 124; break;
7422     case 40:
7423       var $1449=$2;
7424       var $1450=(($1449+64)|0);
7425       var $1451=HEAP32[(($1450)>>2)];
7426       var $1452=$st;
7427       var $1453=(($1452+2)|0);
7428       var $1454=$1453;
7429       var $1455=HEAP16[(($1454)>>1)];
7430       var $1456=(($1455)&65535);
7431       var $1457=(($1451+($1456<<2))|0);
7432       var $1458=$1457;
7433       var $1459=$1458;
7434       var $1460=HEAPF32[(($1459)>>2)];
7435       var $1461=$2;
7436       var $1462=(($1461+64)|0);
7437       var $1463=HEAP32[(($1462)>>2)];
7438       var $1464=$st;
7439       var $1465=(($1464+4)|0);
7440       var $1466=$1465;
7441       var $1467=HEAP16[(($1466)>>1)];
7442       var $1468=(($1467)&65535);
7443       var $1469=(($1463+($1468<<2))|0);
7444       var $1470=$1469;
7445       var $1471=$1470;
7446       var $1472=HEAPF32[(($1471)>>2)];
7447       var $1473=$1460 < $1472;
7448       var $1474=(($1473)&1);
7449       var $1475=(($1474)|0);
7450       var $1476=$2;
7451       var $1477=(($1476+64)|0);
7452       var $1478=HEAP32[(($1477)>>2)];
7453       var $1479=$st;
7454       var $1480=(($1479+6)|0);
7455       var $1481=$1480;
7456       var $1482=HEAP16[(($1481)>>1)];
7457       var $1483=(($1482)&65535);
7458       var $1484=(($1478+($1483<<2))|0);
7459       var $1485=$1484;
7460       var $1486=$1485;
7461       HEAPF32[(($1486)>>2)]=$1475;
7462       __label__ = 124; break;
7463     case 41:
7464       var $1488=$2;
7465       var $1489=(($1488+64)|0);
7466       var $1490=HEAP32[(($1489)>>2)];
7467       var $1491=$st;
7468       var $1492=(($1491+2)|0);
7469       var $1493=$1492;
7470       var $1494=HEAP16[(($1493)>>1)];
7471       var $1495=(($1494)&65535);
7472       var $1496=(($1490+($1495<<2))|0);
7473       var $1497=$1496;
7474       var $1498=$1497;
7475       var $1499=HEAPF32[(($1498)>>2)];
7476       var $1500=$2;
7477       var $1501=(($1500+64)|0);
7478       var $1502=HEAP32[(($1501)>>2)];
7479       var $1503=$st;
7480       var $1504=(($1503+4)|0);
7481       var $1505=$1504;
7482       var $1506=HEAP16[(($1505)>>1)];
7483       var $1507=(($1506)&65535);
7484       var $1508=(($1502+($1507<<2))|0);
7485       var $1509=$1508;
7486       var $1510=$1509;
7487       var $1511=HEAPF32[(($1510)>>2)];
7488       var $1512=$1499 > $1511;
7489       var $1513=(($1512)&1);
7490       var $1514=(($1513)|0);
7491       var $1515=$2;
7492       var $1516=(($1515+64)|0);
7493       var $1517=HEAP32[(($1516)>>2)];
7494       var $1518=$st;
7495       var $1519=(($1518+6)|0);
7496       var $1520=$1519;
7497       var $1521=HEAP16[(($1520)>>1)];
7498       var $1522=(($1521)&65535);
7499       var $1523=(($1517+($1522<<2))|0);
7500       var $1524=$1523;
7501       var $1525=$1524;
7502       HEAPF32[(($1525)>>2)]=$1514;
7503       __label__ = 124; break;
7504     case 42:
7505       var $1527=$2;
7506       var $1528=(($1527+64)|0);
7507       var $1529=HEAP32[(($1528)>>2)];
7508       var $1530=$st;
7509       var $1531=(($1530+2)|0);
7510       var $1532=$1531;
7511       var $1533=HEAP16[(($1532)>>1)];
7512       var $1534=(($1533)&65535);
7513       var $1535=(($1529+($1534<<2))|0);
7514       var $1536=$1535;
7515       var $1537=$1536;
7516       var $1538=HEAP32[(($1537)>>2)];
7517       var $1539=(($1538)|0) < 0;
7518       if ($1539) { __label__ = 44; break; } else { __label__ = 43; break; }
7519     case 43:
7520       var $1541=$2;
7521       var $1542=(($1541+64)|0);
7522       var $1543=HEAP32[(($1542)>>2)];
7523       var $1544=$st;
7524       var $1545=(($1544+2)|0);
7525       var $1546=$1545;
7526       var $1547=HEAP16[(($1546)>>1)];
7527       var $1548=(($1547)&65535);
7528       var $1549=(($1543+($1548<<2))|0);
7529       var $1550=$1549;
7530       var $1551=$1550;
7531       var $1552=HEAP32[(($1551)>>2)];
7532       var $1553=$2;
7533       var $1554=(($1553+140)|0);
7534       var $1555=HEAP32[(($1554)>>2)];
7535       var $1556=(($1552)|0) >= (($1555)|0);
7536       if ($1556) { __label__ = 44; break; } else { __label__ = 45; break; }
7537     case 44:
7538       var $1558=$2;
7539       var $1559=$2;
7540       var $1560=(($1559)|0);
7541       var $1561=HEAP32[(($1560)>>2)];
7542       _qcvmerror($1558, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1561,tempInt));
7543       __label__ = 488; break;
7544     case 45:
7545       var $1563=$2;
7546       var $1564=(($1563+64)|0);
7547       var $1565=HEAP32[(($1564)>>2)];
7548       var $1566=$st;
7549       var $1567=(($1566+4)|0);
7550       var $1568=$1567;
7551       var $1569=HEAP16[(($1568)>>1)];
7552       var $1570=(($1569)&65535);
7553       var $1571=(($1565+($1570<<2))|0);
7554       var $1572=$1571;
7555       var $1573=$1572;
7556       var $1574=HEAP32[(($1573)>>2)];
7557       var $1575=$2;
7558       var $1576=(($1575+144)|0);
7559       var $1577=HEAP32[(($1576)>>2)];
7560       var $1578=(($1574)>>>0) >= (($1577)>>>0);
7561       if ($1578) { __label__ = 46; break; } else { __label__ = 47; break; }
7562     case 46:
7563       var $1580=$2;
7564       var $1581=$2;
7565       var $1582=(($1581)|0);
7566       var $1583=HEAP32[(($1582)>>2)];
7567       var $1584=$2;
7568       var $1585=(($1584+64)|0);
7569       var $1586=HEAP32[(($1585)>>2)];
7570       var $1587=$st;
7571       var $1588=(($1587+4)|0);
7572       var $1589=$1588;
7573       var $1590=HEAP16[(($1589)>>1)];
7574       var $1591=(($1590)&65535);
7575       var $1592=(($1586+($1591<<2))|0);
7576       var $1593=$1592;
7577       var $1594=$1593;
7578       var $1595=HEAP32[(($1594)>>2)];
7579       _qcvmerror($1580, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1583,HEAP32[(((tempInt)+(4))>>2)]=$1595,tempInt));
7580       __label__ = 488; break;
7581     case 47:
7582       var $1597=$2;
7583       var $1598=$2;
7584       var $1599=(($1598+64)|0);
7585       var $1600=HEAP32[(($1599)>>2)];
7586       var $1601=$st;
7587       var $1602=(($1601+2)|0);
7588       var $1603=$1602;
7589       var $1604=HEAP16[(($1603)>>1)];
7590       var $1605=(($1604)&65535);
7591       var $1606=(($1600+($1605<<2))|0);
7592       var $1607=$1606;
7593       var $1608=$1607;
7594       var $1609=HEAP32[(($1608)>>2)];
7595       var $1610=_prog_getedict($1597, $1609);
7596       $ed=$1610;
7597       var $1611=$ed;
7598       var $1612=$1611;
7599       var $1613=$2;
7600       var $1614=(($1613+64)|0);
7601       var $1615=HEAP32[(($1614)>>2)];
7602       var $1616=$st;
7603       var $1617=(($1616+4)|0);
7604       var $1618=$1617;
7605       var $1619=HEAP16[(($1618)>>1)];
7606       var $1620=(($1619)&65535);
7607       var $1621=(($1615+($1620<<2))|0);
7608       var $1622=$1621;
7609       var $1623=$1622;
7610       var $1624=HEAP32[(($1623)>>2)];
7611       var $1625=(($1612+($1624<<2))|0);
7612       var $1626=$1625;
7613       var $1627=$1626;
7614       var $1628=HEAP32[(($1627)>>2)];
7615       var $1629=$2;
7616       var $1630=(($1629+64)|0);
7617       var $1631=HEAP32[(($1630)>>2)];
7618       var $1632=$st;
7619       var $1633=(($1632+6)|0);
7620       var $1634=$1633;
7621       var $1635=HEAP16[(($1634)>>1)];
7622       var $1636=(($1635)&65535);
7623       var $1637=(($1631+($1636<<2))|0);
7624       var $1638=$1637;
7625       var $1639=$1638;
7626       HEAP32[(($1639)>>2)]=$1628;
7627       __label__ = 124; break;
7628     case 48:
7629       var $1641=$2;
7630       var $1642=(($1641+64)|0);
7631       var $1643=HEAP32[(($1642)>>2)];
7632       var $1644=$st;
7633       var $1645=(($1644+2)|0);
7634       var $1646=$1645;
7635       var $1647=HEAP16[(($1646)>>1)];
7636       var $1648=(($1647)&65535);
7637       var $1649=(($1643+($1648<<2))|0);
7638       var $1650=$1649;
7639       var $1651=$1650;
7640       var $1652=HEAP32[(($1651)>>2)];
7641       var $1653=(($1652)|0) < 0;
7642       if ($1653) { __label__ = 50; break; } else { __label__ = 49; break; }
7643     case 49:
7644       var $1655=$2;
7645       var $1656=(($1655+64)|0);
7646       var $1657=HEAP32[(($1656)>>2)];
7647       var $1658=$st;
7648       var $1659=(($1658+2)|0);
7649       var $1660=$1659;
7650       var $1661=HEAP16[(($1660)>>1)];
7651       var $1662=(($1661)&65535);
7652       var $1663=(($1657+($1662<<2))|0);
7653       var $1664=$1663;
7654       var $1665=$1664;
7655       var $1666=HEAP32[(($1665)>>2)];
7656       var $1667=$2;
7657       var $1668=(($1667+140)|0);
7658       var $1669=HEAP32[(($1668)>>2)];
7659       var $1670=(($1666)|0) >= (($1669)|0);
7660       if ($1670) { __label__ = 50; break; } else { __label__ = 51; break; }
7661     case 50:
7662       var $1672=$2;
7663       var $1673=$2;
7664       var $1674=(($1673)|0);
7665       var $1675=HEAP32[(($1674)>>2)];
7666       _qcvmerror($1672, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1675,tempInt));
7667       __label__ = 488; break;
7668     case 51:
7669       var $1677=$2;
7670       var $1678=(($1677+64)|0);
7671       var $1679=HEAP32[(($1678)>>2)];
7672       var $1680=$st;
7673       var $1681=(($1680+4)|0);
7674       var $1682=$1681;
7675       var $1683=HEAP16[(($1682)>>1)];
7676       var $1684=(($1683)&65535);
7677       var $1685=(($1679+($1684<<2))|0);
7678       var $1686=$1685;
7679       var $1687=$1686;
7680       var $1688=HEAP32[(($1687)>>2)];
7681       var $1689=(($1688)|0) < 0;
7682       if ($1689) { __label__ = 53; break; } else { __label__ = 52; break; }
7683     case 52:
7684       var $1691=$2;
7685       var $1692=(($1691+64)|0);
7686       var $1693=HEAP32[(($1692)>>2)];
7687       var $1694=$st;
7688       var $1695=(($1694+4)|0);
7689       var $1696=$1695;
7690       var $1697=HEAP16[(($1696)>>1)];
7691       var $1698=(($1697)&65535);
7692       var $1699=(($1693+($1698<<2))|0);
7693       var $1700=$1699;
7694       var $1701=$1700;
7695       var $1702=HEAP32[(($1701)>>2)];
7696       var $1703=((($1702)+(3))|0);
7697       var $1704=$2;
7698       var $1705=(($1704+144)|0);
7699       var $1706=HEAP32[(($1705)>>2)];
7700       var $1707=(($1703)>>>0) > (($1706)>>>0);
7701       if ($1707) { __label__ = 53; break; } else { __label__ = 54; break; }
7702     case 53:
7703       var $1709=$2;
7704       var $1710=$2;
7705       var $1711=(($1710)|0);
7706       var $1712=HEAP32[(($1711)>>2)];
7707       var $1713=$2;
7708       var $1714=(($1713+64)|0);
7709       var $1715=HEAP32[(($1714)>>2)];
7710       var $1716=$st;
7711       var $1717=(($1716+4)|0);
7712       var $1718=$1717;
7713       var $1719=HEAP16[(($1718)>>1)];
7714       var $1720=(($1719)&65535);
7715       var $1721=(($1715+($1720<<2))|0);
7716       var $1722=$1721;
7717       var $1723=$1722;
7718       var $1724=HEAP32[(($1723)>>2)];
7719       var $1725=((($1724)+(2))|0);
7720       _qcvmerror($1709, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1712,HEAP32[(((tempInt)+(4))>>2)]=$1725,tempInt));
7721       __label__ = 488; break;
7722     case 54:
7723       var $1727=$2;
7724       var $1728=$2;
7725       var $1729=(($1728+64)|0);
7726       var $1730=HEAP32[(($1729)>>2)];
7727       var $1731=$st;
7728       var $1732=(($1731+2)|0);
7729       var $1733=$1732;
7730       var $1734=HEAP16[(($1733)>>1)];
7731       var $1735=(($1734)&65535);
7732       var $1736=(($1730+($1735<<2))|0);
7733       var $1737=$1736;
7734       var $1738=$1737;
7735       var $1739=HEAP32[(($1738)>>2)];
7736       var $1740=_prog_getedict($1727, $1739);
7737       $ed=$1740;
7738       var $1741=$ed;
7739       var $1742=$1741;
7740       var $1743=$2;
7741       var $1744=(($1743+64)|0);
7742       var $1745=HEAP32[(($1744)>>2)];
7743       var $1746=$st;
7744       var $1747=(($1746+4)|0);
7745       var $1748=$1747;
7746       var $1749=HEAP16[(($1748)>>1)];
7747       var $1750=(($1749)&65535);
7748       var $1751=(($1745+($1750<<2))|0);
7749       var $1752=$1751;
7750       var $1753=$1752;
7751       var $1754=HEAP32[(($1753)>>2)];
7752       var $1755=(($1742+($1754<<2))|0);
7753       var $1756=$1755;
7754       var $1757=$1756;
7755       var $1758=(($1757)|0);
7756       var $1759=HEAP32[(($1758)>>2)];
7757       var $1760=$2;
7758       var $1761=(($1760+64)|0);
7759       var $1762=HEAP32[(($1761)>>2)];
7760       var $1763=$st;
7761       var $1764=(($1763+6)|0);
7762       var $1765=$1764;
7763       var $1766=HEAP16[(($1765)>>1)];
7764       var $1767=(($1766)&65535);
7765       var $1768=(($1762+($1767<<2))|0);
7766       var $1769=$1768;
7767       var $1770=$1769;
7768       var $1771=(($1770)|0);
7769       HEAP32[(($1771)>>2)]=$1759;
7770       var $1772=$ed;
7771       var $1773=$1772;
7772       var $1774=$2;
7773       var $1775=(($1774+64)|0);
7774       var $1776=HEAP32[(($1775)>>2)];
7775       var $1777=$st;
7776       var $1778=(($1777+4)|0);
7777       var $1779=$1778;
7778       var $1780=HEAP16[(($1779)>>1)];
7779       var $1781=(($1780)&65535);
7780       var $1782=(($1776+($1781<<2))|0);
7781       var $1783=$1782;
7782       var $1784=$1783;
7783       var $1785=HEAP32[(($1784)>>2)];
7784       var $1786=(($1773+($1785<<2))|0);
7785       var $1787=$1786;
7786       var $1788=$1787;
7787       var $1789=(($1788+4)|0);
7788       var $1790=HEAP32[(($1789)>>2)];
7789       var $1791=$2;
7790       var $1792=(($1791+64)|0);
7791       var $1793=HEAP32[(($1792)>>2)];
7792       var $1794=$st;
7793       var $1795=(($1794+6)|0);
7794       var $1796=$1795;
7795       var $1797=HEAP16[(($1796)>>1)];
7796       var $1798=(($1797)&65535);
7797       var $1799=(($1793+($1798<<2))|0);
7798       var $1800=$1799;
7799       var $1801=$1800;
7800       var $1802=(($1801+4)|0);
7801       HEAP32[(($1802)>>2)]=$1790;
7802       var $1803=$ed;
7803       var $1804=$1803;
7804       var $1805=$2;
7805       var $1806=(($1805+64)|0);
7806       var $1807=HEAP32[(($1806)>>2)];
7807       var $1808=$st;
7808       var $1809=(($1808+4)|0);
7809       var $1810=$1809;
7810       var $1811=HEAP16[(($1810)>>1)];
7811       var $1812=(($1811)&65535);
7812       var $1813=(($1807+($1812<<2))|0);
7813       var $1814=$1813;
7814       var $1815=$1814;
7815       var $1816=HEAP32[(($1815)>>2)];
7816       var $1817=(($1804+($1816<<2))|0);
7817       var $1818=$1817;
7818       var $1819=$1818;
7819       var $1820=(($1819+8)|0);
7820       var $1821=HEAP32[(($1820)>>2)];
7821       var $1822=$2;
7822       var $1823=(($1822+64)|0);
7823       var $1824=HEAP32[(($1823)>>2)];
7824       var $1825=$st;
7825       var $1826=(($1825+6)|0);
7826       var $1827=$1826;
7827       var $1828=HEAP16[(($1827)>>1)];
7828       var $1829=(($1828)&65535);
7829       var $1830=(($1824+($1829<<2))|0);
7830       var $1831=$1830;
7831       var $1832=$1831;
7832       var $1833=(($1832+8)|0);
7833       HEAP32[(($1833)>>2)]=$1821;
7834       __label__ = 124; break;
7835     case 55:
7836       var $1835=$2;
7837       var $1836=(($1835+64)|0);
7838       var $1837=HEAP32[(($1836)>>2)];
7839       var $1838=$st;
7840       var $1839=(($1838+2)|0);
7841       var $1840=$1839;
7842       var $1841=HEAP16[(($1840)>>1)];
7843       var $1842=(($1841)&65535);
7844       var $1843=(($1837+($1842<<2))|0);
7845       var $1844=$1843;
7846       var $1845=$1844;
7847       var $1846=HEAP32[(($1845)>>2)];
7848       var $1847=(($1846)|0) < 0;
7849       if ($1847) { __label__ = 57; break; } else { __label__ = 56; break; }
7850     case 56:
7851       var $1849=$2;
7852       var $1850=(($1849+64)|0);
7853       var $1851=HEAP32[(($1850)>>2)];
7854       var $1852=$st;
7855       var $1853=(($1852+2)|0);
7856       var $1854=$1853;
7857       var $1855=HEAP16[(($1854)>>1)];
7858       var $1856=(($1855)&65535);
7859       var $1857=(($1851+($1856<<2))|0);
7860       var $1858=$1857;
7861       var $1859=$1858;
7862       var $1860=HEAP32[(($1859)>>2)];
7863       var $1861=$2;
7864       var $1862=(($1861+140)|0);
7865       var $1863=HEAP32[(($1862)>>2)];
7866       var $1864=(($1860)|0) >= (($1863)|0);
7867       if ($1864) { __label__ = 57; break; } else { __label__ = 58; break; }
7868     case 57:
7869       var $1866=$2;
7870       var $1867=$2;
7871       var $1868=(($1867)|0);
7872       var $1869=HEAP32[(($1868)>>2)];
7873       var $1870=$2;
7874       var $1871=(($1870+64)|0);
7875       var $1872=HEAP32[(($1871)>>2)];
7876       var $1873=$st;
7877       var $1874=(($1873+2)|0);
7878       var $1875=$1874;
7879       var $1876=HEAP16[(($1875)>>1)];
7880       var $1877=(($1876)&65535);
7881       var $1878=(($1872+($1877<<2))|0);
7882       var $1879=$1878;
7883       var $1880=$1879;
7884       var $1881=HEAP32[(($1880)>>2)];
7885       _qcvmerror($1866, ((STRING_TABLE.__str19)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1869,HEAP32[(((tempInt)+(4))>>2)]=$1881,tempInt));
7886       __label__ = 488; break;
7887     case 58:
7888       var $1883=$2;
7889       var $1884=(($1883+64)|0);
7890       var $1885=HEAP32[(($1884)>>2)];
7891       var $1886=$st;
7892       var $1887=(($1886+4)|0);
7893       var $1888=$1887;
7894       var $1889=HEAP16[(($1888)>>1)];
7895       var $1890=(($1889)&65535);
7896       var $1891=(($1885+($1890<<2))|0);
7897       var $1892=$1891;
7898       var $1893=$1892;
7899       var $1894=HEAP32[(($1893)>>2)];
7900       var $1895=$2;
7901       var $1896=(($1895+144)|0);
7902       var $1897=HEAP32[(($1896)>>2)];
7903       var $1898=(($1894)>>>0) >= (($1897)>>>0);
7904       if ($1898) { __label__ = 59; break; } else { __label__ = 60; break; }
7905     case 59:
7906       var $1900=$2;
7907       var $1901=$2;
7908       var $1902=(($1901)|0);
7909       var $1903=HEAP32[(($1902)>>2)];
7910       var $1904=$2;
7911       var $1905=(($1904+64)|0);
7912       var $1906=HEAP32[(($1905)>>2)];
7913       var $1907=$st;
7914       var $1908=(($1907+4)|0);
7915       var $1909=$1908;
7916       var $1910=HEAP16[(($1909)>>1)];
7917       var $1911=(($1910)&65535);
7918       var $1912=(($1906+($1911<<2))|0);
7919       var $1913=$1912;
7920       var $1914=$1913;
7921       var $1915=HEAP32[(($1914)>>2)];
7922       _qcvmerror($1900, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1903,HEAP32[(((tempInt)+(4))>>2)]=$1915,tempInt));
7923       __label__ = 488; break;
7924     case 60:
7925       var $1917=$2;
7926       var $1918=$2;
7927       var $1919=(($1918+64)|0);
7928       var $1920=HEAP32[(($1919)>>2)];
7929       var $1921=$st;
7930       var $1922=(($1921+2)|0);
7931       var $1923=$1922;
7932       var $1924=HEAP16[(($1923)>>1)];
7933       var $1925=(($1924)&65535);
7934       var $1926=(($1920+($1925<<2))|0);
7935       var $1927=$1926;
7936       var $1928=$1927;
7937       var $1929=HEAP32[(($1928)>>2)];
7938       var $1930=_prog_getedict($1917, $1929);
7939       $ed=$1930;
7940       var $1931=$ed;
7941       var $1932=$1931;
7942       var $1933=$2;
7943       var $1934=(($1933+76)|0);
7944       var $1935=HEAP32[(($1934)>>2)];
7945       var $1936=$1932;
7946       var $1937=$1935;
7947       var $1938=((($1936)-($1937))|0);
7948       var $1939=((((($1938)|0))/(4))&-1);
7949       var $1940=$2;
7950       var $1941=(($1940+64)|0);
7951       var $1942=HEAP32[(($1941)>>2)];
7952       var $1943=$st;
7953       var $1944=(($1943+6)|0);
7954       var $1945=$1944;
7955       var $1946=HEAP16[(($1945)>>1)];
7956       var $1947=(($1946)&65535);
7957       var $1948=(($1942+($1947<<2))|0);
7958       var $1949=$1948;
7959       var $1950=$1949;
7960       HEAP32[(($1950)>>2)]=$1939;
7961       var $1951=$2;
7962       var $1952=(($1951+64)|0);
7963       var $1953=HEAP32[(($1952)>>2)];
7964       var $1954=$st;
7965       var $1955=(($1954+4)|0);
7966       var $1956=$1955;
7967       var $1957=HEAP16[(($1956)>>1)];
7968       var $1958=(($1957)&65535);
7969       var $1959=(($1953+($1958<<2))|0);
7970       var $1960=$1959;
7971       var $1961=$1960;
7972       var $1962=HEAP32[(($1961)>>2)];
7973       var $1963=$2;
7974       var $1964=(($1963+64)|0);
7975       var $1965=HEAP32[(($1964)>>2)];
7976       var $1966=$st;
7977       var $1967=(($1966+6)|0);
7978       var $1968=$1967;
7979       var $1969=HEAP16[(($1968)>>1)];
7980       var $1970=(($1969)&65535);
7981       var $1971=(($1965+($1970<<2))|0);
7982       var $1972=$1971;
7983       var $1973=$1972;
7984       var $1974=HEAP32[(($1973)>>2)];
7985       var $1975=((($1974)+($1962))|0);
7986       HEAP32[(($1973)>>2)]=$1975;
7987       __label__ = 124; break;
7988     case 61:
7989       var $1977=$2;
7990       var $1978=(($1977+64)|0);
7991       var $1979=HEAP32[(($1978)>>2)];
7992       var $1980=$st;
7993       var $1981=(($1980+2)|0);
7994       var $1982=$1981;
7995       var $1983=HEAP16[(($1982)>>1)];
7996       var $1984=(($1983)&65535);
7997       var $1985=(($1979+($1984<<2))|0);
7998       var $1986=$1985;
7999       var $1987=$1986;
8000       var $1988=HEAP32[(($1987)>>2)];
8001       var $1989=$2;
8002       var $1990=(($1989+64)|0);
8003       var $1991=HEAP32[(($1990)>>2)];
8004       var $1992=$st;
8005       var $1993=(($1992+4)|0);
8006       var $1994=$1993;
8007       var $1995=HEAP16[(($1994)>>1)];
8008       var $1996=(($1995)&65535);
8009       var $1997=(($1991+($1996<<2))|0);
8010       var $1998=$1997;
8011       var $1999=$1998;
8012       HEAP32[(($1999)>>2)]=$1988;
8013       __label__ = 124; break;
8014     case 62:
8015       var $2001=$2;
8016       var $2002=(($2001+64)|0);
8017       var $2003=HEAP32[(($2002)>>2)];
8018       var $2004=$st;
8019       var $2005=(($2004+2)|0);
8020       var $2006=$2005;
8021       var $2007=HEAP16[(($2006)>>1)];
8022       var $2008=(($2007)&65535);
8023       var $2009=(($2003+($2008<<2))|0);
8024       var $2010=$2009;
8025       var $2011=$2010;
8026       var $2012=(($2011)|0);
8027       var $2013=HEAP32[(($2012)>>2)];
8028       var $2014=$2;
8029       var $2015=(($2014+64)|0);
8030       var $2016=HEAP32[(($2015)>>2)];
8031       var $2017=$st;
8032       var $2018=(($2017+4)|0);
8033       var $2019=$2018;
8034       var $2020=HEAP16[(($2019)>>1)];
8035       var $2021=(($2020)&65535);
8036       var $2022=(($2016+($2021<<2))|0);
8037       var $2023=$2022;
8038       var $2024=$2023;
8039       var $2025=(($2024)|0);
8040       HEAP32[(($2025)>>2)]=$2013;
8041       var $2026=$2;
8042       var $2027=(($2026+64)|0);
8043       var $2028=HEAP32[(($2027)>>2)];
8044       var $2029=$st;
8045       var $2030=(($2029+2)|0);
8046       var $2031=$2030;
8047       var $2032=HEAP16[(($2031)>>1)];
8048       var $2033=(($2032)&65535);
8049       var $2034=(($2028+($2033<<2))|0);
8050       var $2035=$2034;
8051       var $2036=$2035;
8052       var $2037=(($2036+4)|0);
8053       var $2038=HEAP32[(($2037)>>2)];
8054       var $2039=$2;
8055       var $2040=(($2039+64)|0);
8056       var $2041=HEAP32[(($2040)>>2)];
8057       var $2042=$st;
8058       var $2043=(($2042+4)|0);
8059       var $2044=$2043;
8060       var $2045=HEAP16[(($2044)>>1)];
8061       var $2046=(($2045)&65535);
8062       var $2047=(($2041+($2046<<2))|0);
8063       var $2048=$2047;
8064       var $2049=$2048;
8065       var $2050=(($2049+4)|0);
8066       HEAP32[(($2050)>>2)]=$2038;
8067       var $2051=$2;
8068       var $2052=(($2051+64)|0);
8069       var $2053=HEAP32[(($2052)>>2)];
8070       var $2054=$st;
8071       var $2055=(($2054+2)|0);
8072       var $2056=$2055;
8073       var $2057=HEAP16[(($2056)>>1)];
8074       var $2058=(($2057)&65535);
8075       var $2059=(($2053+($2058<<2))|0);
8076       var $2060=$2059;
8077       var $2061=$2060;
8078       var $2062=(($2061+8)|0);
8079       var $2063=HEAP32[(($2062)>>2)];
8080       var $2064=$2;
8081       var $2065=(($2064+64)|0);
8082       var $2066=HEAP32[(($2065)>>2)];
8083       var $2067=$st;
8084       var $2068=(($2067+4)|0);
8085       var $2069=$2068;
8086       var $2070=HEAP16[(($2069)>>1)];
8087       var $2071=(($2070)&65535);
8088       var $2072=(($2066+($2071<<2))|0);
8089       var $2073=$2072;
8090       var $2074=$2073;
8091       var $2075=(($2074+8)|0);
8092       HEAP32[(($2075)>>2)]=$2063;
8093       __label__ = 124; break;
8094     case 63:
8095       var $2077=$2;
8096       var $2078=(($2077+64)|0);
8097       var $2079=HEAP32[(($2078)>>2)];
8098       var $2080=$st;
8099       var $2081=(($2080+4)|0);
8100       var $2082=$2081;
8101       var $2083=HEAP16[(($2082)>>1)];
8102       var $2084=(($2083)&65535);
8103       var $2085=(($2079+($2084<<2))|0);
8104       var $2086=$2085;
8105       var $2087=$2086;
8106       var $2088=HEAP32[(($2087)>>2)];
8107       var $2089=(($2088)|0) < 0;
8108       if ($2089) { __label__ = 65; break; } else { __label__ = 64; break; }
8109     case 64:
8110       var $2091=$2;
8111       var $2092=(($2091+64)|0);
8112       var $2093=HEAP32[(($2092)>>2)];
8113       var $2094=$st;
8114       var $2095=(($2094+4)|0);
8115       var $2096=$2095;
8116       var $2097=HEAP16[(($2096)>>1)];
8117       var $2098=(($2097)&65535);
8118       var $2099=(($2093+($2098<<2))|0);
8119       var $2100=$2099;
8120       var $2101=$2100;
8121       var $2102=HEAP32[(($2101)>>2)];
8122       var $2103=$2;
8123       var $2104=(($2103+80)|0);
8124       var $2105=HEAP32[(($2104)>>2)];
8125       var $2106=(($2102)>>>0) >= (($2105)>>>0);
8126       if ($2106) { __label__ = 65; break; } else { __label__ = 66; break; }
8127     case 65:
8128       var $2108=$2;
8129       var $2109=$2;
8130       var $2110=(($2109)|0);
8131       var $2111=HEAP32[(($2110)>>2)];
8132       var $2112=$2;
8133       var $2113=(($2112+64)|0);
8134       var $2114=HEAP32[(($2113)>>2)];
8135       var $2115=$st;
8136       var $2116=(($2115+4)|0);
8137       var $2117=$2116;
8138       var $2118=HEAP16[(($2117)>>1)];
8139       var $2119=(($2118)&65535);
8140       var $2120=(($2114+($2119<<2))|0);
8141       var $2121=$2120;
8142       var $2122=$2121;
8143       var $2123=HEAP32[(($2122)>>2)];
8144       _qcvmerror($2108, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2111,HEAP32[(((tempInt)+(4))>>2)]=$2123,tempInt));
8145       __label__ = 488; break;
8146     case 66:
8147       var $2125=$2;
8148       var $2126=(($2125+64)|0);
8149       var $2127=HEAP32[(($2126)>>2)];
8150       var $2128=$st;
8151       var $2129=(($2128+4)|0);
8152       var $2130=$2129;
8153       var $2131=HEAP16[(($2130)>>1)];
8154       var $2132=(($2131)&65535);
8155       var $2133=(($2127+($2132<<2))|0);
8156       var $2134=$2133;
8157       var $2135=$2134;
8158       var $2136=HEAP32[(($2135)>>2)];
8159       var $2137=$2;
8160       var $2138=(($2137+144)|0);
8161       var $2139=HEAP32[(($2138)>>2)];
8162       var $2140=(($2136)>>>0) < (($2139)>>>0);
8163       if ($2140) { __label__ = 67; break; } else { __label__ = 69; break; }
8164     case 67:
8165       var $2142=$2;
8166       var $2143=(($2142+148)|0);
8167       var $2144=HEAP8[($2143)];
8168       var $2145=(($2144) & 1);
8169       if ($2145) { __label__ = 69; break; } else { __label__ = 68; break; }
8170     case 68:
8171       var $2147=$2;
8172       var $2148=$2;
8173       var $2149=(($2148)|0);
8174       var $2150=HEAP32[(($2149)>>2)];
8175       var $2151=$2;
8176       var $2152=$2;
8177       var $2153=$2;
8178       var $2154=(($2153+64)|0);
8179       var $2155=HEAP32[(($2154)>>2)];
8180       var $2156=$st;
8181       var $2157=(($2156+4)|0);
8182       var $2158=$2157;
8183       var $2159=HEAP16[(($2158)>>1)];
8184       var $2160=(($2159)&65535);
8185       var $2161=(($2155+($2160<<2))|0);
8186       var $2162=$2161;
8187       var $2163=$2162;
8188       var $2164=HEAP32[(($2163)>>2)];
8189       var $2165=_prog_entfield($2152, $2164);
8190       var $2166=(($2165+4)|0);
8191       var $2167=HEAP32[(($2166)>>2)];
8192       var $2168=_prog_getstring($2151, $2167);
8193       var $2169=$2;
8194       var $2170=(($2169+64)|0);
8195       var $2171=HEAP32[(($2170)>>2)];
8196       var $2172=$st;
8197       var $2173=(($2172+4)|0);
8198       var $2174=$2173;
8199       var $2175=HEAP16[(($2174)>>1)];
8200       var $2176=(($2175)&65535);
8201       var $2177=(($2171+($2176<<2))|0);
8202       var $2178=$2177;
8203       var $2179=$2178;
8204       var $2180=HEAP32[(($2179)>>2)];
8205       _qcvmerror($2147, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2150,HEAP32[(((tempInt)+(4))>>2)]=$2168,HEAP32[(((tempInt)+(8))>>2)]=$2180,tempInt));
8206       __label__ = 69; break;
8207     case 69:
8208       var $2182=$2;
8209       var $2183=(($2182+76)|0);
8210       var $2184=HEAP32[(($2183)>>2)];
8211       var $2185=$2;
8212       var $2186=(($2185+64)|0);
8213       var $2187=HEAP32[(($2186)>>2)];
8214       var $2188=$st;
8215       var $2189=(($2188+4)|0);
8216       var $2190=$2189;
8217       var $2191=HEAP16[(($2190)>>1)];
8218       var $2192=(($2191)&65535);
8219       var $2193=(($2187+($2192<<2))|0);
8220       var $2194=$2193;
8221       var $2195=$2194;
8222       var $2196=HEAP32[(($2195)>>2)];
8223       var $2197=(($2184+($2196<<2))|0);
8224       var $2198=$2197;
8225       $ptr=$2198;
8226       var $2199=$2;
8227       var $2200=(($2199+64)|0);
8228       var $2201=HEAP32[(($2200)>>2)];
8229       var $2202=$st;
8230       var $2203=(($2202+2)|0);
8231       var $2204=$2203;
8232       var $2205=HEAP16[(($2204)>>1)];
8233       var $2206=(($2205)&65535);
8234       var $2207=(($2201+($2206<<2))|0);
8235       var $2208=$2207;
8236       var $2209=$2208;
8237       var $2210=HEAP32[(($2209)>>2)];
8238       var $2211=$ptr;
8239       var $2212=$2211;
8240       HEAP32[(($2212)>>2)]=$2210;
8241       __label__ = 124; break;
8242     case 70:
8243       var $2214=$2;
8244       var $2215=(($2214+64)|0);
8245       var $2216=HEAP32[(($2215)>>2)];
8246       var $2217=$st;
8247       var $2218=(($2217+4)|0);
8248       var $2219=$2218;
8249       var $2220=HEAP16[(($2219)>>1)];
8250       var $2221=(($2220)&65535);
8251       var $2222=(($2216+($2221<<2))|0);
8252       var $2223=$2222;
8253       var $2224=$2223;
8254       var $2225=HEAP32[(($2224)>>2)];
8255       var $2226=(($2225)|0) < 0;
8256       if ($2226) { __label__ = 72; break; } else { __label__ = 71; break; }
8257     case 71:
8258       var $2228=$2;
8259       var $2229=(($2228+64)|0);
8260       var $2230=HEAP32[(($2229)>>2)];
8261       var $2231=$st;
8262       var $2232=(($2231+4)|0);
8263       var $2233=$2232;
8264       var $2234=HEAP16[(($2233)>>1)];
8265       var $2235=(($2234)&65535);
8266       var $2236=(($2230+($2235<<2))|0);
8267       var $2237=$2236;
8268       var $2238=$2237;
8269       var $2239=HEAP32[(($2238)>>2)];
8270       var $2240=((($2239)+(2))|0);
8271       var $2241=$2;
8272       var $2242=(($2241+80)|0);
8273       var $2243=HEAP32[(($2242)>>2)];
8274       var $2244=(($2240)>>>0) >= (($2243)>>>0);
8275       if ($2244) { __label__ = 72; break; } else { __label__ = 73; break; }
8276     case 72:
8277       var $2246=$2;
8278       var $2247=$2;
8279       var $2248=(($2247)|0);
8280       var $2249=HEAP32[(($2248)>>2)];
8281       var $2250=$2;
8282       var $2251=(($2250+64)|0);
8283       var $2252=HEAP32[(($2251)>>2)];
8284       var $2253=$st;
8285       var $2254=(($2253+4)|0);
8286       var $2255=$2254;
8287       var $2256=HEAP16[(($2255)>>1)];
8288       var $2257=(($2256)&65535);
8289       var $2258=(($2252+($2257<<2))|0);
8290       var $2259=$2258;
8291       var $2260=$2259;
8292       var $2261=HEAP32[(($2260)>>2)];
8293       _qcvmerror($2246, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2249,HEAP32[(((tempInt)+(4))>>2)]=$2261,tempInt));
8294       __label__ = 488; break;
8295     case 73:
8296       var $2263=$2;
8297       var $2264=(($2263+64)|0);
8298       var $2265=HEAP32[(($2264)>>2)];
8299       var $2266=$st;
8300       var $2267=(($2266+4)|0);
8301       var $2268=$2267;
8302       var $2269=HEAP16[(($2268)>>1)];
8303       var $2270=(($2269)&65535);
8304       var $2271=(($2265+($2270<<2))|0);
8305       var $2272=$2271;
8306       var $2273=$2272;
8307       var $2274=HEAP32[(($2273)>>2)];
8308       var $2275=$2;
8309       var $2276=(($2275+144)|0);
8310       var $2277=HEAP32[(($2276)>>2)];
8311       var $2278=(($2274)>>>0) < (($2277)>>>0);
8312       if ($2278) { __label__ = 74; break; } else { __label__ = 76; break; }
8313     case 74:
8314       var $2280=$2;
8315       var $2281=(($2280+148)|0);
8316       var $2282=HEAP8[($2281)];
8317       var $2283=(($2282) & 1);
8318       if ($2283) { __label__ = 76; break; } else { __label__ = 75; break; }
8319     case 75:
8320       var $2285=$2;
8321       var $2286=$2;
8322       var $2287=(($2286)|0);
8323       var $2288=HEAP32[(($2287)>>2)];
8324       var $2289=$2;
8325       var $2290=$2;
8326       var $2291=$2;
8327       var $2292=(($2291+64)|0);
8328       var $2293=HEAP32[(($2292)>>2)];
8329       var $2294=$st;
8330       var $2295=(($2294+4)|0);
8331       var $2296=$2295;
8332       var $2297=HEAP16[(($2296)>>1)];
8333       var $2298=(($2297)&65535);
8334       var $2299=(($2293+($2298<<2))|0);
8335       var $2300=$2299;
8336       var $2301=$2300;
8337       var $2302=HEAP32[(($2301)>>2)];
8338       var $2303=_prog_entfield($2290, $2302);
8339       var $2304=(($2303+4)|0);
8340       var $2305=HEAP32[(($2304)>>2)];
8341       var $2306=_prog_getstring($2289, $2305);
8342       var $2307=$2;
8343       var $2308=(($2307+64)|0);
8344       var $2309=HEAP32[(($2308)>>2)];
8345       var $2310=$st;
8346       var $2311=(($2310+4)|0);
8347       var $2312=$2311;
8348       var $2313=HEAP16[(($2312)>>1)];
8349       var $2314=(($2313)&65535);
8350       var $2315=(($2309+($2314<<2))|0);
8351       var $2316=$2315;
8352       var $2317=$2316;
8353       var $2318=HEAP32[(($2317)>>2)];
8354       _qcvmerror($2285, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2288,HEAP32[(((tempInt)+(4))>>2)]=$2306,HEAP32[(((tempInt)+(8))>>2)]=$2318,tempInt));
8355       __label__ = 76; break;
8356     case 76:
8357       var $2320=$2;
8358       var $2321=(($2320+76)|0);
8359       var $2322=HEAP32[(($2321)>>2)];
8360       var $2323=$2;
8361       var $2324=(($2323+64)|0);
8362       var $2325=HEAP32[(($2324)>>2)];
8363       var $2326=$st;
8364       var $2327=(($2326+4)|0);
8365       var $2328=$2327;
8366       var $2329=HEAP16[(($2328)>>1)];
8367       var $2330=(($2329)&65535);
8368       var $2331=(($2325+($2330<<2))|0);
8369       var $2332=$2331;
8370       var $2333=$2332;
8371       var $2334=HEAP32[(($2333)>>2)];
8372       var $2335=(($2322+($2334<<2))|0);
8373       var $2336=$2335;
8374       $ptr=$2336;
8375       var $2337=$2;
8376       var $2338=(($2337+64)|0);
8377       var $2339=HEAP32[(($2338)>>2)];
8378       var $2340=$st;
8379       var $2341=(($2340+2)|0);
8380       var $2342=$2341;
8381       var $2343=HEAP16[(($2342)>>1)];
8382       var $2344=(($2343)&65535);
8383       var $2345=(($2339+($2344<<2))|0);
8384       var $2346=$2345;
8385       var $2347=$2346;
8386       var $2348=(($2347)|0);
8387       var $2349=HEAP32[(($2348)>>2)];
8388       var $2350=$ptr;
8389       var $2351=$2350;
8390       var $2352=(($2351)|0);
8391       HEAP32[(($2352)>>2)]=$2349;
8392       var $2353=$2;
8393       var $2354=(($2353+64)|0);
8394       var $2355=HEAP32[(($2354)>>2)];
8395       var $2356=$st;
8396       var $2357=(($2356+2)|0);
8397       var $2358=$2357;
8398       var $2359=HEAP16[(($2358)>>1)];
8399       var $2360=(($2359)&65535);
8400       var $2361=(($2355+($2360<<2))|0);
8401       var $2362=$2361;
8402       var $2363=$2362;
8403       var $2364=(($2363+4)|0);
8404       var $2365=HEAP32[(($2364)>>2)];
8405       var $2366=$ptr;
8406       var $2367=$2366;
8407       var $2368=(($2367+4)|0);
8408       HEAP32[(($2368)>>2)]=$2365;
8409       var $2369=$2;
8410       var $2370=(($2369+64)|0);
8411       var $2371=HEAP32[(($2370)>>2)];
8412       var $2372=$st;
8413       var $2373=(($2372+2)|0);
8414       var $2374=$2373;
8415       var $2375=HEAP16[(($2374)>>1)];
8416       var $2376=(($2375)&65535);
8417       var $2377=(($2371+($2376<<2))|0);
8418       var $2378=$2377;
8419       var $2379=$2378;
8420       var $2380=(($2379+8)|0);
8421       var $2381=HEAP32[(($2380)>>2)];
8422       var $2382=$ptr;
8423       var $2383=$2382;
8424       var $2384=(($2383+8)|0);
8425       HEAP32[(($2384)>>2)]=$2381;
8426       __label__ = 124; break;
8427     case 77:
8428       var $2386=$2;
8429       var $2387=(($2386+64)|0);
8430       var $2388=HEAP32[(($2387)>>2)];
8431       var $2389=$st;
8432       var $2390=(($2389+2)|0);
8433       var $2391=$2390;
8434       var $2392=HEAP16[(($2391)>>1)];
8435       var $2393=(($2392)&65535);
8436       var $2394=(($2388+($2393<<2))|0);
8437       var $2395=$2394;
8438       var $2396=$2395;
8439       var $2397=HEAP32[(($2396)>>2)];
8440       var $2398=$2397 & 2147483647;
8441       var $2399=(($2398)|0)!=0;
8442       var $2400=$2399 ^ 1;
8443       var $2401=(($2400)&1);
8444       var $2402=(($2401)|0);
8445       var $2403=$2;
8446       var $2404=(($2403+64)|0);
8447       var $2405=HEAP32[(($2404)>>2)];
8448       var $2406=$st;
8449       var $2407=(($2406+6)|0);
8450       var $2408=$2407;
8451       var $2409=HEAP16[(($2408)>>1)];
8452       var $2410=(($2409)&65535);
8453       var $2411=(($2405+($2410<<2))|0);
8454       var $2412=$2411;
8455       var $2413=$2412;
8456       HEAPF32[(($2413)>>2)]=$2402;
8457       __label__ = 124; break;
8458     case 78:
8459       var $2415=$2;
8460       var $2416=(($2415+64)|0);
8461       var $2417=HEAP32[(($2416)>>2)];
8462       var $2418=$st;
8463       var $2419=(($2418+2)|0);
8464       var $2420=$2419;
8465       var $2421=HEAP16[(($2420)>>1)];
8466       var $2422=(($2421)&65535);
8467       var $2423=(($2417+($2422<<2))|0);
8468       var $2424=$2423;
8469       var $2425=$2424;
8470       var $2426=(($2425)|0);
8471       var $2427=HEAPF32[(($2426)>>2)];
8472       var $2428=$2427 != 0;
8473       if ($2428) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 79; break; }
8474     case 79:
8475       var $2430=$2;
8476       var $2431=(($2430+64)|0);
8477       var $2432=HEAP32[(($2431)>>2)];
8478       var $2433=$st;
8479       var $2434=(($2433+2)|0);
8480       var $2435=$2434;
8481       var $2436=HEAP16[(($2435)>>1)];
8482       var $2437=(($2436)&65535);
8483       var $2438=(($2432+($2437<<2))|0);
8484       var $2439=$2438;
8485       var $2440=$2439;
8486       var $2441=(($2440+4)|0);
8487       var $2442=HEAPF32[(($2441)>>2)];
8488       var $2443=$2442 != 0;
8489       if ($2443) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 80; break; }
8490     case 80:
8491       var $2445=$2;
8492       var $2446=(($2445+64)|0);
8493       var $2447=HEAP32[(($2446)>>2)];
8494       var $2448=$st;
8495       var $2449=(($2448+2)|0);
8496       var $2450=$2449;
8497       var $2451=HEAP16[(($2450)>>1)];
8498       var $2452=(($2451)&65535);
8499       var $2453=(($2447+($2452<<2))|0);
8500       var $2454=$2453;
8501       var $2455=$2454;
8502       var $2456=(($2455+8)|0);
8503       var $2457=HEAPF32[(($2456)>>2)];
8504       var $2458=$2457 != 0;
8505       var $2459=$2458 ^ 1;
8506       var $2461 = $2459;__label__ = 81; break;
8507     case 81:
8508       var $2461;
8509       var $2462=(($2461)&1);
8510       var $2463=(($2462)|0);
8511       var $2464=$2;
8512       var $2465=(($2464+64)|0);
8513       var $2466=HEAP32[(($2465)>>2)];
8514       var $2467=$st;
8515       var $2468=(($2467+6)|0);
8516       var $2469=$2468;
8517       var $2470=HEAP16[(($2469)>>1)];
8518       var $2471=(($2470)&65535);
8519       var $2472=(($2466+($2471<<2))|0);
8520       var $2473=$2472;
8521       var $2474=$2473;
8522       HEAPF32[(($2474)>>2)]=$2463;
8523       __label__ = 124; break;
8524     case 82:
8525       var $2476=$2;
8526       var $2477=(($2476+64)|0);
8527       var $2478=HEAP32[(($2477)>>2)];
8528       var $2479=$st;
8529       var $2480=(($2479+2)|0);
8530       var $2481=$2480;
8531       var $2482=HEAP16[(($2481)>>1)];
8532       var $2483=(($2482)&65535);
8533       var $2484=(($2478+($2483<<2))|0);
8534       var $2485=$2484;
8535       var $2486=$2485;
8536       var $2487=HEAP32[(($2486)>>2)];
8537       var $2488=(($2487)|0)!=0;
8538       if ($2488) { __label__ = 83; break; } else { var $2508 = 1;__label__ = 84; break; }
8539     case 83:
8540       var $2490=$2;
8541       var $2491=$2;
8542       var $2492=(($2491+64)|0);
8543       var $2493=HEAP32[(($2492)>>2)];
8544       var $2494=$st;
8545       var $2495=(($2494+2)|0);
8546       var $2496=$2495;
8547       var $2497=HEAP16[(($2496)>>1)];
8548       var $2498=(($2497)&65535);
8549       var $2499=(($2493+($2498<<2))|0);
8550       var $2500=$2499;
8551       var $2501=$2500;
8552       var $2502=HEAP32[(($2501)>>2)];
8553       var $2503=_prog_getstring($2490, $2502);
8554       var $2504=HEAP8[($2503)];
8555       var $2505=(($2504 << 24) >> 24)!=0;
8556       var $2506=$2505 ^ 1;
8557       var $2508 = $2506;__label__ = 84; break;
8558     case 84:
8559       var $2508;
8560       var $2509=(($2508)&1);
8561       var $2510=(($2509)|0);
8562       var $2511=$2;
8563       var $2512=(($2511+64)|0);
8564       var $2513=HEAP32[(($2512)>>2)];
8565       var $2514=$st;
8566       var $2515=(($2514+6)|0);
8567       var $2516=$2515;
8568       var $2517=HEAP16[(($2516)>>1)];
8569       var $2518=(($2517)&65535);
8570       var $2519=(($2513+($2518<<2))|0);
8571       var $2520=$2519;
8572       var $2521=$2520;
8573       HEAPF32[(($2521)>>2)]=$2510;
8574       __label__ = 124; break;
8575     case 85:
8576       var $2523=$2;
8577       var $2524=(($2523+64)|0);
8578       var $2525=HEAP32[(($2524)>>2)];
8579       var $2526=$st;
8580       var $2527=(($2526+2)|0);
8581       var $2528=$2527;
8582       var $2529=HEAP16[(($2528)>>1)];
8583       var $2530=(($2529)&65535);
8584       var $2531=(($2525+($2530<<2))|0);
8585       var $2532=$2531;
8586       var $2533=$2532;
8587       var $2534=HEAP32[(($2533)>>2)];
8588       var $2535=(($2534)|0)==0;
8589       var $2536=(($2535)&1);
8590       var $2537=(($2536)|0);
8591       var $2538=$2;
8592       var $2539=(($2538+64)|0);
8593       var $2540=HEAP32[(($2539)>>2)];
8594       var $2541=$st;
8595       var $2542=(($2541+6)|0);
8596       var $2543=$2542;
8597       var $2544=HEAP16[(($2543)>>1)];
8598       var $2545=(($2544)&65535);
8599       var $2546=(($2540+($2545<<2))|0);
8600       var $2547=$2546;
8601       var $2548=$2547;
8602       HEAPF32[(($2548)>>2)]=$2537;
8603       __label__ = 124; break;
8604     case 86:
8605       var $2550=$2;
8606       var $2551=(($2550+64)|0);
8607       var $2552=HEAP32[(($2551)>>2)];
8608       var $2553=$st;
8609       var $2554=(($2553+2)|0);
8610       var $2555=$2554;
8611       var $2556=HEAP16[(($2555)>>1)];
8612       var $2557=(($2556)&65535);
8613       var $2558=(($2552+($2557<<2))|0);
8614       var $2559=$2558;
8615       var $2560=$2559;
8616       var $2561=HEAP32[(($2560)>>2)];
8617       var $2562=(($2561)|0)!=0;
8618       var $2563=$2562 ^ 1;
8619       var $2564=(($2563)&1);
8620       var $2565=(($2564)|0);
8621       var $2566=$2;
8622       var $2567=(($2566+64)|0);
8623       var $2568=HEAP32[(($2567)>>2)];
8624       var $2569=$st;
8625       var $2570=(($2569+6)|0);
8626       var $2571=$2570;
8627       var $2572=HEAP16[(($2571)>>1)];
8628       var $2573=(($2572)&65535);
8629       var $2574=(($2568+($2573<<2))|0);
8630       var $2575=$2574;
8631       var $2576=$2575;
8632       HEAPF32[(($2576)>>2)]=$2565;
8633       __label__ = 124; break;
8634     case 87:
8635       var $2578=$2;
8636       var $2579=(($2578+64)|0);
8637       var $2580=HEAP32[(($2579)>>2)];
8638       var $2581=$st;
8639       var $2582=(($2581+2)|0);
8640       var $2583=$2582;
8641       var $2584=HEAP16[(($2583)>>1)];
8642       var $2585=(($2584)&65535);
8643       var $2586=(($2580+($2585<<2))|0);
8644       var $2587=$2586;
8645       var $2588=$2587;
8646       var $2589=HEAP32[(($2588)>>2)];
8647       var $2590=$2589 & 2147483647;
8648       var $2591=(($2590)|0)!=0;
8649       if ($2591) { __label__ = 88; break; } else { __label__ = 91; break; }
8650     case 88:
8651       var $2593=$st;
8652       var $2594=(($2593+4)|0);
8653       var $2595=$2594;
8654       var $2596=HEAP16[(($2595)>>1)];
8655       var $2597=(($2596 << 16) >> 16);
8656       var $2598=((($2597)-(1))|0);
8657       var $2599=$st;
8658       var $2600=(($2599+($2598<<3))|0);
8659       $st=$2600;
8660       var $2601=$jumpcount;
8661       var $2602=((($2601)+(1))|0);
8662       $jumpcount=$2602;
8663       var $2603=$5;
8664       var $2604=(($2602)|0) >= (($2603)|0);
8665       if ($2604) { __label__ = 89; break; } else { __label__ = 90; break; }
8666     case 89:
8667       var $2606=$2;
8668       var $2607=$2;
8669       var $2608=(($2607)|0);
8670       var $2609=HEAP32[(($2608)>>2)];
8671       var $2610=$jumpcount;
8672       _qcvmerror($2606, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2609,HEAP32[(((tempInt)+(4))>>2)]=$2610,tempInt));
8673       __label__ = 90; break;
8674     case 90:
8675       __label__ = 91; break;
8676     case 91:
8677       __label__ = 124; break;
8678     case 92:
8679       var $2614=$2;
8680       var $2615=(($2614+64)|0);
8681       var $2616=HEAP32[(($2615)>>2)];
8682       var $2617=$st;
8683       var $2618=(($2617+2)|0);
8684       var $2619=$2618;
8685       var $2620=HEAP16[(($2619)>>1)];
8686       var $2621=(($2620)&65535);
8687       var $2622=(($2616+($2621<<2))|0);
8688       var $2623=$2622;
8689       var $2624=$2623;
8690       var $2625=HEAP32[(($2624)>>2)];
8691       var $2626=$2625 & 2147483647;
8692       var $2627=(($2626)|0)!=0;
8693       if ($2627) { __label__ = 96; break; } else { __label__ = 93; break; }
8694     case 93:
8695       var $2629=$st;
8696       var $2630=(($2629+4)|0);
8697       var $2631=$2630;
8698       var $2632=HEAP16[(($2631)>>1)];
8699       var $2633=(($2632 << 16) >> 16);
8700       var $2634=((($2633)-(1))|0);
8701       var $2635=$st;
8702       var $2636=(($2635+($2634<<3))|0);
8703       $st=$2636;
8704       var $2637=$jumpcount;
8705       var $2638=((($2637)+(1))|0);
8706       $jumpcount=$2638;
8707       var $2639=$5;
8708       var $2640=(($2638)|0) >= (($2639)|0);
8709       if ($2640) { __label__ = 94; break; } else { __label__ = 95; break; }
8710     case 94:
8711       var $2642=$2;
8712       var $2643=$2;
8713       var $2644=(($2643)|0);
8714       var $2645=HEAP32[(($2644)>>2)];
8715       var $2646=$jumpcount;
8716       _qcvmerror($2642, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2645,HEAP32[(((tempInt)+(4))>>2)]=$2646,tempInt));
8717       __label__ = 95; break;
8718     case 95:
8719       __label__ = 96; break;
8720     case 96:
8721       __label__ = 124; break;
8722     case 97:
8723       var $2650=$st;
8724       var $2651=(($2650)|0);
8725       var $2652=HEAP16[(($2651)>>1)];
8726       var $2653=(($2652)&65535);
8727       var $2654=((($2653)-(51))|0);
8728       var $2655=$2;
8729       var $2656=(($2655+184)|0);
8730       HEAP32[(($2656)>>2)]=$2654;
8731       var $2657=$2;
8732       var $2658=(($2657+64)|0);
8733       var $2659=HEAP32[(($2658)>>2)];
8734       var $2660=$st;
8735       var $2661=(($2660+2)|0);
8736       var $2662=$2661;
8737       var $2663=HEAP16[(($2662)>>1)];
8738       var $2664=(($2663)&65535);
8739       var $2665=(($2659+($2664<<2))|0);
8740       var $2666=$2665;
8741       var $2667=$2666;
8742       var $2668=HEAP32[(($2667)>>2)];
8743       var $2669=(($2668)|0)!=0;
8744       if ($2669) { __label__ = 99; break; } else { __label__ = 98; break; }
8745     case 98:
8746       var $2671=$2;
8747       var $2672=$2;
8748       var $2673=(($2672)|0);
8749       var $2674=HEAP32[(($2673)>>2)];
8750       _qcvmerror($2671, ((STRING_TABLE.__str23)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2674,tempInt));
8751       __label__ = 99; break;
8752     case 99:
8753       var $2676=$2;
8754       var $2677=(($2676+64)|0);
8755       var $2678=HEAP32[(($2677)>>2)];
8756       var $2679=$st;
8757       var $2680=(($2679+2)|0);
8758       var $2681=$2680;
8759       var $2682=HEAP16[(($2681)>>1)];
8760       var $2683=(($2682)&65535);
8761       var $2684=(($2678+($2683<<2))|0);
8762       var $2685=$2684;
8763       var $2686=$2685;
8764       var $2687=HEAP32[(($2686)>>2)];
8765       var $2688=(($2687)|0)!=0;
8766       if ($2688) { __label__ = 100; break; } else { __label__ = 101; break; }
8767     case 100:
8768       var $2690=$2;
8769       var $2691=(($2690+64)|0);
8770       var $2692=HEAP32[(($2691)>>2)];
8771       var $2693=$st;
8772       var $2694=(($2693+2)|0);
8773       var $2695=$2694;
8774       var $2696=HEAP16[(($2695)>>1)];
8775       var $2697=(($2696)&65535);
8776       var $2698=(($2692+($2697<<2))|0);
8777       var $2699=$2698;
8778       var $2700=$2699;
8779       var $2701=HEAP32[(($2700)>>2)];
8780       var $2702=$2;
8781       var $2703=(($2702+44)|0);
8782       var $2704=HEAP32[(($2703)>>2)];
8783       var $2705=(($2701)>>>0) >= (($2704)>>>0);
8784       if ($2705) { __label__ = 101; break; } else { __label__ = 102; break; }
8785     case 101:
8786       var $2707=$2;
8787       var $2708=$2;
8788       var $2709=(($2708)|0);
8789       var $2710=HEAP32[(($2709)>>2)];
8790       _qcvmerror($2707, ((STRING_TABLE.__str24)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2710,tempInt));
8791       __label__ = 488; break;
8792     case 102:
8793       var $2712=$2;
8794       var $2713=(($2712+64)|0);
8795       var $2714=HEAP32[(($2713)>>2)];
8796       var $2715=$st;
8797       var $2716=(($2715+2)|0);
8798       var $2717=$2716;
8799       var $2718=HEAP16[(($2717)>>1)];
8800       var $2719=(($2718)&65535);
8801       var $2720=(($2714+($2719<<2))|0);
8802       var $2721=$2720;
8803       var $2722=$2721;
8804       var $2723=HEAP32[(($2722)>>2)];
8805       var $2724=$2;
8806       var $2725=(($2724+40)|0);
8807       var $2726=HEAP32[(($2725)>>2)];
8808       var $2727=(($2726+($2723)*(36))|0);
8809       $newf=$2727;
8810       var $2728=$newf;
8811       var $2729=(($2728+12)|0);
8812       var $2730=HEAP32[(($2729)>>2)];
8813       var $2731=((($2730)+(1))|0);
8814       HEAP32[(($2729)>>2)]=$2731;
8815       var $2732=$st;
8816       var $2733=$2;
8817       var $2734=(($2733+4)|0);
8818       var $2735=HEAP32[(($2734)>>2)];
8819       var $2736=$2732;
8820       var $2737=$2735;
8821       var $2738=((($2736)-($2737))|0);
8822       var $2739=((((($2738)|0))/(8))&-1);
8823       var $2740=((($2739)+(1))|0);
8824       var $2741=$2;
8825       var $2742=(($2741+176)|0);
8826       HEAP32[(($2742)>>2)]=$2740;
8827       var $2743=$newf;
8828       var $2744=(($2743)|0);
8829       var $2745=HEAP32[(($2744)>>2)];
8830       var $2746=(($2745)|0) < 0;
8831       if ($2746) { __label__ = 103; break; } else { __label__ = 108; break; }
8832     case 103:
8833       var $2748=$newf;
8834       var $2749=(($2748)|0);
8835       var $2750=HEAP32[(($2749)>>2)];
8836       var $2751=(((-$2750))|0);
8837       $builtinnumber=$2751;
8838       var $2752=$builtinnumber;
8839       var $2753=$2;
8840       var $2754=(($2753+132)|0);
8841       var $2755=HEAP32[(($2754)>>2)];
8842       var $2756=(($2752)>>>0) < (($2755)>>>0);
8843       if ($2756) { __label__ = 104; break; } else { __label__ = 106; break; }
8844     case 104:
8845       var $2758=$builtinnumber;
8846       var $2759=$2;
8847       var $2760=(($2759+128)|0);
8848       var $2761=HEAP32[(($2760)>>2)];
8849       var $2762=(($2761+($2758<<2))|0);
8850       var $2763=HEAP32[(($2762)>>2)];
8851       var $2764=(($2763)|0)!=0;
8852       if ($2764) { __label__ = 105; break; } else { __label__ = 106; break; }
8853     case 105:
8854       var $2766=$builtinnumber;
8855       var $2767=$2;
8856       var $2768=(($2767+128)|0);
8857       var $2769=HEAP32[(($2768)>>2)];
8858       var $2770=(($2769+($2766<<2))|0);
8859       var $2771=HEAP32[(($2770)>>2)];
8860       var $2772=$2;
8861       var $2773=FUNCTION_TABLE[$2771]($2772);
8862       __label__ = 107; break;
8863     case 106:
8864       var $2775=$2;
8865       var $2776=$builtinnumber;
8866       var $2777=$2;
8867       var $2778=(($2777)|0);
8868       var $2779=HEAP32[(($2778)>>2)];
8869       _qcvmerror($2775, ((STRING_TABLE.__str25)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2776,HEAP32[(((tempInt)+(4))>>2)]=$2779,tempInt));
8870       __label__ = 107; break;
8871     case 107:
8872       __label__ = 109; break;
8873     case 108:
8874       var $2782=$2;
8875       var $2783=(($2782+4)|0);
8876       var $2784=HEAP32[(($2783)>>2)];
8877       var $2785=$2;
8878       var $2786=$newf;
8879       var $2787=_prog_enterfunction($2785, $2786);
8880       var $2788=(($2784+($2787<<3))|0);
8881       var $2789=((($2788)-(8))|0);
8882       $st=$2789;
8883       __label__ = 109; break;
8884     case 109:
8885       var $2791=$2;
8886       var $2792=(($2791+112)|0);
8887       var $2793=HEAP32[(($2792)>>2)];
8888       var $2794=(($2793)|0)!=0;
8889       if ($2794) { __label__ = 110; break; } else { __label__ = 111; break; }
8890     case 110:
8891       __label__ = 488; break;
8892     case 111:
8893       __label__ = 124; break;
8894     case 112:
8895       var $2798=$2;
8896       var $2799=$2;
8897       var $2800=(($2799)|0);
8898       var $2801=HEAP32[(($2800)>>2)];
8899       _qcvmerror($2798, ((STRING_TABLE.__str26)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2801,tempInt));
8900       __label__ = 124; break;
8901     case 113:
8902       var $2803=$st;
8903       var $2804=(($2803+2)|0);
8904       var $2805=$2804;
8905       var $2806=HEAP16[(($2805)>>1)];
8906       var $2807=(($2806 << 16) >> 16);
8907       var $2808=((($2807)-(1))|0);
8908       var $2809=$st;
8909       var $2810=(($2809+($2808<<3))|0);
8910       $st=$2810;
8911       var $2811=$jumpcount;
8912       var $2812=((($2811)+(1))|0);
8913       $jumpcount=$2812;
8914       var $2813=(($2812)|0)==10000000;
8915       if ($2813) { __label__ = 114; break; } else { __label__ = 115; break; }
8916     case 114:
8917       var $2815=$2;
8918       var $2816=$2;
8919       var $2817=(($2816)|0);
8920       var $2818=HEAP32[(($2817)>>2)];
8921       var $2819=$jumpcount;
8922       _qcvmerror($2815, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2818,HEAP32[(((tempInt)+(4))>>2)]=$2819,tempInt));
8923       __label__ = 115; break;
8924     case 115:
8925       __label__ = 124; break;
8926     case 116:
8927       var $2822=$2;
8928       var $2823=(($2822+64)|0);
8929       var $2824=HEAP32[(($2823)>>2)];
8930       var $2825=$st;
8931       var $2826=(($2825+2)|0);
8932       var $2827=$2826;
8933       var $2828=HEAP16[(($2827)>>1)];
8934       var $2829=(($2828)&65535);
8935       var $2830=(($2824+($2829<<2))|0);
8936       var $2831=$2830;
8937       var $2832=$2831;
8938       var $2833=HEAP32[(($2832)>>2)];
8939       var $2834=$2833 & 2147483647;
8940       var $2835=(($2834)|0)!=0;
8941       if ($2835) { __label__ = 117; break; } else { var $2852 = 0;__label__ = 118; break; }
8942     case 117:
8943       var $2837=$2;
8944       var $2838=(($2837+64)|0);
8945       var $2839=HEAP32[(($2838)>>2)];
8946       var $2840=$st;
8947       var $2841=(($2840+4)|0);
8948       var $2842=$2841;
8949       var $2843=HEAP16[(($2842)>>1)];
8950       var $2844=(($2843)&65535);
8951       var $2845=(($2839+($2844<<2))|0);
8952       var $2846=$2845;
8953       var $2847=$2846;
8954       var $2848=HEAP32[(($2847)>>2)];
8955       var $2849=$2848 & 2147483647;
8956       var $2850=(($2849)|0)!=0;
8957       var $2852 = $2850;__label__ = 118; break;
8958     case 118:
8959       var $2852;
8960       var $2853=(($2852)&1);
8961       var $2854=(($2853)|0);
8962       var $2855=$2;
8963       var $2856=(($2855+64)|0);
8964       var $2857=HEAP32[(($2856)>>2)];
8965       var $2858=$st;
8966       var $2859=(($2858+6)|0);
8967       var $2860=$2859;
8968       var $2861=HEAP16[(($2860)>>1)];
8969       var $2862=(($2861)&65535);
8970       var $2863=(($2857+($2862<<2))|0);
8971       var $2864=$2863;
8972       var $2865=$2864;
8973       HEAPF32[(($2865)>>2)]=$2854;
8974       __label__ = 124; break;
8975     case 119:
8976       var $2867=$2;
8977       var $2868=(($2867+64)|0);
8978       var $2869=HEAP32[(($2868)>>2)];
8979       var $2870=$st;
8980       var $2871=(($2870+2)|0);
8981       var $2872=$2871;
8982       var $2873=HEAP16[(($2872)>>1)];
8983       var $2874=(($2873)&65535);
8984       var $2875=(($2869+($2874<<2))|0);
8985       var $2876=$2875;
8986       var $2877=$2876;
8987       var $2878=HEAP32[(($2877)>>2)];
8988       var $2879=$2878 & 2147483647;
8989       var $2880=(($2879)|0)!=0;
8990       if ($2880) { var $2897 = 1;__label__ = 121; break; } else { __label__ = 120; break; }
8991     case 120:
8992       var $2882=$2;
8993       var $2883=(($2882+64)|0);
8994       var $2884=HEAP32[(($2883)>>2)];
8995       var $2885=$st;
8996       var $2886=(($2885+4)|0);
8997       var $2887=$2886;
8998       var $2888=HEAP16[(($2887)>>1)];
8999       var $2889=(($2888)&65535);
9000       var $2890=(($2884+($2889<<2))|0);
9001       var $2891=$2890;
9002       var $2892=$2891;
9003       var $2893=HEAP32[(($2892)>>2)];
9004       var $2894=$2893 & 2147483647;
9005       var $2895=(($2894)|0)!=0;
9006       var $2897 = $2895;__label__ = 121; break;
9007     case 121:
9008       var $2897;
9009       var $2898=(($2897)&1);
9010       var $2899=(($2898)|0);
9011       var $2900=$2;
9012       var $2901=(($2900+64)|0);
9013       var $2902=HEAP32[(($2901)>>2)];
9014       var $2903=$st;
9015       var $2904=(($2903+6)|0);
9016       var $2905=$2904;
9017       var $2906=HEAP16[(($2905)>>1)];
9018       var $2907=(($2906)&65535);
9019       var $2908=(($2902+($2907<<2))|0);
9020       var $2909=$2908;
9021       var $2910=$2909;
9022       HEAPF32[(($2910)>>2)]=$2899;
9023       __label__ = 124; break;
9024     case 122:
9025       var $2912=$2;
9026       var $2913=(($2912+64)|0);
9027       var $2914=HEAP32[(($2913)>>2)];
9028       var $2915=$st;
9029       var $2916=(($2915+2)|0);
9030       var $2917=$2916;
9031       var $2918=HEAP16[(($2917)>>1)];
9032       var $2919=(($2918)&65535);
9033       var $2920=(($2914+($2919<<2))|0);
9034       var $2921=$2920;
9035       var $2922=$2921;
9036       var $2923=HEAPF32[(($2922)>>2)];
9037       var $2924=(($2923)&-1);
9038       var $2925=$2;
9039       var $2926=(($2925+64)|0);
9040       var $2927=HEAP32[(($2926)>>2)];
9041       var $2928=$st;
9042       var $2929=(($2928+4)|0);
9043       var $2930=$2929;
9044       var $2931=HEAP16[(($2930)>>1)];
9045       var $2932=(($2931)&65535);
9046       var $2933=(($2927+($2932<<2))|0);
9047       var $2934=$2933;
9048       var $2935=$2934;
9049       var $2936=HEAPF32[(($2935)>>2)];
9050       var $2937=(($2936)&-1);
9051       var $2938=$2924 & $2937;
9052       var $2939=(($2938)|0);
9053       var $2940=$2;
9054       var $2941=(($2940+64)|0);
9055       var $2942=HEAP32[(($2941)>>2)];
9056       var $2943=$st;
9057       var $2944=(($2943+6)|0);
9058       var $2945=$2944;
9059       var $2946=HEAP16[(($2945)>>1)];
9060       var $2947=(($2946)&65535);
9061       var $2948=(($2942+($2947<<2))|0);
9062       var $2949=$2948;
9063       var $2950=$2949;
9064       HEAPF32[(($2950)>>2)]=$2939;
9065       __label__ = 124; break;
9066     case 123:
9067       var $2952=$2;
9068       var $2953=(($2952+64)|0);
9069       var $2954=HEAP32[(($2953)>>2)];
9070       var $2955=$st;
9071       var $2956=(($2955+2)|0);
9072       var $2957=$2956;
9073       var $2958=HEAP16[(($2957)>>1)];
9074       var $2959=(($2958)&65535);
9075       var $2960=(($2954+($2959<<2))|0);
9076       var $2961=$2960;
9077       var $2962=$2961;
9078       var $2963=HEAPF32[(($2962)>>2)];
9079       var $2964=(($2963)&-1);
9080       var $2965=$2;
9081       var $2966=(($2965+64)|0);
9082       var $2967=HEAP32[(($2966)>>2)];
9083       var $2968=$st;
9084       var $2969=(($2968+4)|0);
9085       var $2970=$2969;
9086       var $2971=HEAP16[(($2970)>>1)];
9087       var $2972=(($2971)&65535);
9088       var $2973=(($2967+($2972<<2))|0);
9089       var $2974=$2973;
9090       var $2975=$2974;
9091       var $2976=HEAPF32[(($2975)>>2)];
9092       var $2977=(($2976)&-1);
9093       var $2978=$2964 | $2977;
9094       var $2979=(($2978)|0);
9095       var $2980=$2;
9096       var $2981=(($2980+64)|0);
9097       var $2982=HEAP32[(($2981)>>2)];
9098       var $2983=$st;
9099       var $2984=(($2983+6)|0);
9100       var $2985=$2984;
9101       var $2986=HEAP16[(($2985)>>1)];
9102       var $2987=(($2986)&65535);
9103       var $2988=(($2982+($2987<<2))|0);
9104       var $2989=$2988;
9105       var $2990=$2989;
9106       HEAPF32[(($2990)>>2)]=$2979;
9107       __label__ = 124; break;
9108     case 124:
9109       __label__ = 5; break;
9110     case 125:
9111       __label__ = 126; break;
9112     case 126:
9113       var $2994=$st;
9114       var $2995=(($2994+8)|0);
9115       $st=$2995;
9116       var $2996=$2;
9117       var $2997=$st;
9118       _prog_print_statement($2996, $2997);
9119       var $2998=$st;
9120       var $2999=(($2998)|0);
9121       var $3000=HEAP16[(($2999)>>1)];
9122       var $3001=(($3000)&65535);
9123       if ((($3001)|0) == 0 || (($3001)|0) == 43) {
9124         __label__ = 128; break;
9125       }
9126       else if ((($3001)|0) == 1) {
9127         __label__ = 131; break;
9128       }
9129       else if ((($3001)|0) == 2) {
9130         __label__ = 132; break;
9131       }
9132       else if ((($3001)|0) == 3) {
9133         __label__ = 133; break;
9134       }
9135       else if ((($3001)|0) == 4) {
9136         __label__ = 134; break;
9137       }
9138       else if ((($3001)|0) == 5) {
9139         __label__ = 135; break;
9140       }
9141       else if ((($3001)|0) == 6) {
9142         __label__ = 139; break;
9143       }
9144       else if ((($3001)|0) == 7) {
9145         __label__ = 140; break;
9146       }
9147       else if ((($3001)|0) == 8) {
9148         __label__ = 141; break;
9149       }
9150       else if ((($3001)|0) == 9) {
9151         __label__ = 142; break;
9152       }
9153       else if ((($3001)|0) == 10) {
9154         __label__ = 143; break;
9155       }
9156       else if ((($3001)|0) == 11) {
9157         __label__ = 144; break;
9158       }
9159       else if ((($3001)|0) == 12) {
9160         __label__ = 148; break;
9161       }
9162       else if ((($3001)|0) == 13) {
9163         __label__ = 149; break;
9164       }
9165       else if ((($3001)|0) == 14) {
9166         __label__ = 150; break;
9167       }
9168       else if ((($3001)|0) == 15) {
9169         __label__ = 151; break;
9170       }
9171       else if ((($3001)|0) == 16) {
9172         __label__ = 152; break;
9173       }
9174       else if ((($3001)|0) == 17) {
9175         __label__ = 156; break;
9176       }
9177       else if ((($3001)|0) == 18) {
9178         __label__ = 157; break;
9179       }
9180       else if ((($3001)|0) == 19) {
9181         __label__ = 158; break;
9182       }
9183       else if ((($3001)|0) == 20) {
9184         __label__ = 159; break;
9185       }
9186       else if ((($3001)|0) == 21) {
9187         __label__ = 160; break;
9188       }
9189       else if ((($3001)|0) == 22) {
9190         __label__ = 161; break;
9191       }
9192       else if ((($3001)|0) == 23) {
9193         __label__ = 162; break;
9194       }
9195       else if ((($3001)|0) == 24 || (($3001)|0) == 26 || (($3001)|0) == 28 || (($3001)|0) == 27 || (($3001)|0) == 29) {
9196         __label__ = 163; break;
9197       }
9198       else if ((($3001)|0) == 25) {
9199         __label__ = 169; break;
9200       }
9201       else if ((($3001)|0) == 30) {
9202         __label__ = 176; break;
9203       }
9204       else if ((($3001)|0) == 31 || (($3001)|0) == 33 || (($3001)|0) == 34 || (($3001)|0) == 35 || (($3001)|0) == 36) {
9205         __label__ = 182; break;
9206       }
9207       else if ((($3001)|0) == 32) {
9208         __label__ = 183; break;
9209       }
9210       else if ((($3001)|0) == 37 || (($3001)|0) == 39 || (($3001)|0) == 40 || (($3001)|0) == 41 || (($3001)|0) == 42) {
9211         __label__ = 184; break;
9212       }
9213       else if ((($3001)|0) == 38) {
9214         __label__ = 191; break;
9215       }
9216       else if ((($3001)|0) == 44) {
9217         __label__ = 198; break;
9218       }
9219       else if ((($3001)|0) == 45) {
9220         __label__ = 199; break;
9221       }
9222       else if ((($3001)|0) == 46) {
9223         __label__ = 203; break;
9224       }
9225       else if ((($3001)|0) == 47) {
9226         __label__ = 206; break;
9227       }
9228       else if ((($3001)|0) == 48) {
9229         __label__ = 207; break;
9230       }
9231       else if ((($3001)|0) == 49) {
9232         __label__ = 208; break;
9233       }
9234       else if ((($3001)|0) == 50) {
9235         __label__ = 213; break;
9236       }
9237       else if ((($3001)|0) == 51 || (($3001)|0) == 52 || (($3001)|0) == 53 || (($3001)|0) == 54 || (($3001)|0) == 55 || (($3001)|0) == 56 || (($3001)|0) == 57 || (($3001)|0) == 58 || (($3001)|0) == 59) {
9238         __label__ = 218; break;
9239       }
9240       else if ((($3001)|0) == 60) {
9241         __label__ = 233; break;
9242       }
9243       else if ((($3001)|0) == 61) {
9244         __label__ = 234; break;
9245       }
9246       else if ((($3001)|0) == 62) {
9247         __label__ = 237; break;
9248       }
9249       else if ((($3001)|0) == 63) {
9250         __label__ = 240; break;
9251       }
9252       else if ((($3001)|0) == 64) {
9253         __label__ = 243; break;
9254       }
9255       else if ((($3001)|0) == 65) {
9256         __label__ = 244; break;
9257       }
9258       else {
9259       __label__ = 127; break;
9260       }
9261
9262     case 127:
9263       var $3003=$2;
9264       var $3004=$2;
9265       var $3005=(($3004)|0);
9266       var $3006=HEAP32[(($3005)>>2)];
9267       _qcvmerror($3003, ((STRING_TABLE.__str16)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$3006,tempInt));
9268       __label__ = 488; break;
9269     case 128:
9270       var $3008=$2;
9271       var $3009=(($3008+64)|0);
9272       var $3010=HEAP32[(($3009)>>2)];
9273       var $3011=$st;
9274       var $3012=(($3011+2)|0);
9275       var $3013=$3012;
9276       var $3014=HEAP16[(($3013)>>1)];
9277       var $3015=(($3014)&65535);
9278       var $3016=(($3010+($3015<<2))|0);
9279       var $3017=$3016;
9280       var $3018=$3017;
9281       var $3019=(($3018)|0);
9282       var $3020=HEAP32[(($3019)>>2)];
9283       var $3021=$2;
9284       var $3022=(($3021+64)|0);
9285       var $3023=HEAP32[(($3022)>>2)];
9286       var $3024=(($3023+4)|0);
9287       var $3025=$3024;
9288       var $3026=$3025;
9289       var $3027=(($3026)|0);
9290       HEAP32[(($3027)>>2)]=$3020;
9291       var $3028=$2;
9292       var $3029=(($3028+64)|0);
9293       var $3030=HEAP32[(($3029)>>2)];
9294       var $3031=$st;
9295       var $3032=(($3031+2)|0);
9296       var $3033=$3032;
9297       var $3034=HEAP16[(($3033)>>1)];
9298       var $3035=(($3034)&65535);
9299       var $3036=(($3030+($3035<<2))|0);
9300       var $3037=$3036;
9301       var $3038=$3037;
9302       var $3039=(($3038+4)|0);
9303       var $3040=HEAP32[(($3039)>>2)];
9304       var $3041=$2;
9305       var $3042=(($3041+64)|0);
9306       var $3043=HEAP32[(($3042)>>2)];
9307       var $3044=(($3043+4)|0);
9308       var $3045=$3044;
9309       var $3046=$3045;
9310       var $3047=(($3046+4)|0);
9311       HEAP32[(($3047)>>2)]=$3040;
9312       var $3048=$2;
9313       var $3049=(($3048+64)|0);
9314       var $3050=HEAP32[(($3049)>>2)];
9315       var $3051=$st;
9316       var $3052=(($3051+2)|0);
9317       var $3053=$3052;
9318       var $3054=HEAP16[(($3053)>>1)];
9319       var $3055=(($3054)&65535);
9320       var $3056=(($3050+($3055<<2))|0);
9321       var $3057=$3056;
9322       var $3058=$3057;
9323       var $3059=(($3058+8)|0);
9324       var $3060=HEAP32[(($3059)>>2)];
9325       var $3061=$2;
9326       var $3062=(($3061+64)|0);
9327       var $3063=HEAP32[(($3062)>>2)];
9328       var $3064=(($3063+4)|0);
9329       var $3065=$3064;
9330       var $3066=$3065;
9331       var $3067=(($3066+8)|0);
9332       HEAP32[(($3067)>>2)]=$3060;
9333       var $3068=$2;
9334       var $3069=(($3068+4)|0);
9335       var $3070=HEAP32[(($3069)>>2)];
9336       var $3071=$2;
9337       var $3072=_prog_leavefunction($3071);
9338       var $3073=(($3070+($3072<<3))|0);
9339       $st=$3073;
9340       var $3074=$2;
9341       var $3075=(($3074+168)|0);
9342       var $3076=HEAP32[(($3075)>>2)];
9343       var $3077=(($3076)|0)!=0;
9344       if ($3077) { __label__ = 130; break; } else { __label__ = 129; break; }
9345     case 129:
9346       __label__ = 488; break;
9347     case 130:
9348       __label__ = 245; break;
9349     case 131:
9350       var $3081=$2;
9351       var $3082=(($3081+64)|0);
9352       var $3083=HEAP32[(($3082)>>2)];
9353       var $3084=$st;
9354       var $3085=(($3084+2)|0);
9355       var $3086=$3085;
9356       var $3087=HEAP16[(($3086)>>1)];
9357       var $3088=(($3087)&65535);
9358       var $3089=(($3083+($3088<<2))|0);
9359       var $3090=$3089;
9360       var $3091=$3090;
9361       var $3092=HEAPF32[(($3091)>>2)];
9362       var $3093=$2;
9363       var $3094=(($3093+64)|0);
9364       var $3095=HEAP32[(($3094)>>2)];
9365       var $3096=$st;
9366       var $3097=(($3096+4)|0);
9367       var $3098=$3097;
9368       var $3099=HEAP16[(($3098)>>1)];
9369       var $3100=(($3099)&65535);
9370       var $3101=(($3095+($3100<<2))|0);
9371       var $3102=$3101;
9372       var $3103=$3102;
9373       var $3104=HEAPF32[(($3103)>>2)];
9374       var $3105=($3092)*($3104);
9375       var $3106=$2;
9376       var $3107=(($3106+64)|0);
9377       var $3108=HEAP32[(($3107)>>2)];
9378       var $3109=$st;
9379       var $3110=(($3109+6)|0);
9380       var $3111=$3110;
9381       var $3112=HEAP16[(($3111)>>1)];
9382       var $3113=(($3112)&65535);
9383       var $3114=(($3108+($3113<<2))|0);
9384       var $3115=$3114;
9385       var $3116=$3115;
9386       HEAPF32[(($3116)>>2)]=$3105;
9387       __label__ = 245; break;
9388     case 132:
9389       var $3118=$2;
9390       var $3119=(($3118+64)|0);
9391       var $3120=HEAP32[(($3119)>>2)];
9392       var $3121=$st;
9393       var $3122=(($3121+2)|0);
9394       var $3123=$3122;
9395       var $3124=HEAP16[(($3123)>>1)];
9396       var $3125=(($3124)&65535);
9397       var $3126=(($3120+($3125<<2))|0);
9398       var $3127=$3126;
9399       var $3128=$3127;
9400       var $3129=(($3128)|0);
9401       var $3130=HEAPF32[(($3129)>>2)];
9402       var $3131=$2;
9403       var $3132=(($3131+64)|0);
9404       var $3133=HEAP32[(($3132)>>2)];
9405       var $3134=$st;
9406       var $3135=(($3134+4)|0);
9407       var $3136=$3135;
9408       var $3137=HEAP16[(($3136)>>1)];
9409       var $3138=(($3137)&65535);
9410       var $3139=(($3133+($3138<<2))|0);
9411       var $3140=$3139;
9412       var $3141=$3140;
9413       var $3142=(($3141)|0);
9414       var $3143=HEAPF32[(($3142)>>2)];
9415       var $3144=($3130)*($3143);
9416       var $3145=$2;
9417       var $3146=(($3145+64)|0);
9418       var $3147=HEAP32[(($3146)>>2)];
9419       var $3148=$st;
9420       var $3149=(($3148+2)|0);
9421       var $3150=$3149;
9422       var $3151=HEAP16[(($3150)>>1)];
9423       var $3152=(($3151)&65535);
9424       var $3153=(($3147+($3152<<2))|0);
9425       var $3154=$3153;
9426       var $3155=$3154;
9427       var $3156=(($3155+4)|0);
9428       var $3157=HEAPF32[(($3156)>>2)];
9429       var $3158=$2;
9430       var $3159=(($3158+64)|0);
9431       var $3160=HEAP32[(($3159)>>2)];
9432       var $3161=$st;
9433       var $3162=(($3161+4)|0);
9434       var $3163=$3162;
9435       var $3164=HEAP16[(($3163)>>1)];
9436       var $3165=(($3164)&65535);
9437       var $3166=(($3160+($3165<<2))|0);
9438       var $3167=$3166;
9439       var $3168=$3167;
9440       var $3169=(($3168+4)|0);
9441       var $3170=HEAPF32[(($3169)>>2)];
9442       var $3171=($3157)*($3170);
9443       var $3172=($3144)+($3171);
9444       var $3173=$2;
9445       var $3174=(($3173+64)|0);
9446       var $3175=HEAP32[(($3174)>>2)];
9447       var $3176=$st;
9448       var $3177=(($3176+2)|0);
9449       var $3178=$3177;
9450       var $3179=HEAP16[(($3178)>>1)];
9451       var $3180=(($3179)&65535);
9452       var $3181=(($3175+($3180<<2))|0);
9453       var $3182=$3181;
9454       var $3183=$3182;
9455       var $3184=(($3183+8)|0);
9456       var $3185=HEAPF32[(($3184)>>2)];
9457       var $3186=$2;
9458       var $3187=(($3186+64)|0);
9459       var $3188=HEAP32[(($3187)>>2)];
9460       var $3189=$st;
9461       var $3190=(($3189+4)|0);
9462       var $3191=$3190;
9463       var $3192=HEAP16[(($3191)>>1)];
9464       var $3193=(($3192)&65535);
9465       var $3194=(($3188+($3193<<2))|0);
9466       var $3195=$3194;
9467       var $3196=$3195;
9468       var $3197=(($3196+8)|0);
9469       var $3198=HEAPF32[(($3197)>>2)];
9470       var $3199=($3185)*($3198);
9471       var $3200=($3172)+($3199);
9472       var $3201=$2;
9473       var $3202=(($3201+64)|0);
9474       var $3203=HEAP32[(($3202)>>2)];
9475       var $3204=$st;
9476       var $3205=(($3204+6)|0);
9477       var $3206=$3205;
9478       var $3207=HEAP16[(($3206)>>1)];
9479       var $3208=(($3207)&65535);
9480       var $3209=(($3203+($3208<<2))|0);
9481       var $3210=$3209;
9482       var $3211=$3210;
9483       HEAPF32[(($3211)>>2)]=$3200;
9484       __label__ = 245; break;
9485     case 133:
9486       var $3213=$2;
9487       var $3214=(($3213+64)|0);
9488       var $3215=HEAP32[(($3214)>>2)];
9489       var $3216=$st;
9490       var $3217=(($3216+2)|0);
9491       var $3218=$3217;
9492       var $3219=HEAP16[(($3218)>>1)];
9493       var $3220=(($3219)&65535);
9494       var $3221=(($3215+($3220<<2))|0);
9495       var $3222=$3221;
9496       var $3223=$3222;
9497       var $3224=HEAPF32[(($3223)>>2)];
9498       var $3225=$2;
9499       var $3226=(($3225+64)|0);
9500       var $3227=HEAP32[(($3226)>>2)];
9501       var $3228=$st;
9502       var $3229=(($3228+4)|0);
9503       var $3230=$3229;
9504       var $3231=HEAP16[(($3230)>>1)];
9505       var $3232=(($3231)&65535);
9506       var $3233=(($3227+($3232<<2))|0);
9507       var $3234=$3233;
9508       var $3235=$3234;
9509       var $3236=(($3235)|0);
9510       var $3237=HEAPF32[(($3236)>>2)];
9511       var $3238=($3224)*($3237);
9512       var $3239=$2;
9513       var $3240=(($3239+64)|0);
9514       var $3241=HEAP32[(($3240)>>2)];
9515       var $3242=$st;
9516       var $3243=(($3242+6)|0);
9517       var $3244=$3243;
9518       var $3245=HEAP16[(($3244)>>1)];
9519       var $3246=(($3245)&65535);
9520       var $3247=(($3241+($3246<<2))|0);
9521       var $3248=$3247;
9522       var $3249=$3248;
9523       var $3250=(($3249)|0);
9524       HEAPF32[(($3250)>>2)]=$3238;
9525       var $3251=$2;
9526       var $3252=(($3251+64)|0);
9527       var $3253=HEAP32[(($3252)>>2)];
9528       var $3254=$st;
9529       var $3255=(($3254+2)|0);
9530       var $3256=$3255;
9531       var $3257=HEAP16[(($3256)>>1)];
9532       var $3258=(($3257)&65535);
9533       var $3259=(($3253+($3258<<2))|0);
9534       var $3260=$3259;
9535       var $3261=$3260;
9536       var $3262=HEAPF32[(($3261)>>2)];
9537       var $3263=$2;
9538       var $3264=(($3263+64)|0);
9539       var $3265=HEAP32[(($3264)>>2)];
9540       var $3266=$st;
9541       var $3267=(($3266+4)|0);
9542       var $3268=$3267;
9543       var $3269=HEAP16[(($3268)>>1)];
9544       var $3270=(($3269)&65535);
9545       var $3271=(($3265+($3270<<2))|0);
9546       var $3272=$3271;
9547       var $3273=$3272;
9548       var $3274=(($3273+4)|0);
9549       var $3275=HEAPF32[(($3274)>>2)];
9550       var $3276=($3262)*($3275);
9551       var $3277=$2;
9552       var $3278=(($3277+64)|0);
9553       var $3279=HEAP32[(($3278)>>2)];
9554       var $3280=$st;
9555       var $3281=(($3280+6)|0);
9556       var $3282=$3281;
9557       var $3283=HEAP16[(($3282)>>1)];
9558       var $3284=(($3283)&65535);
9559       var $3285=(($3279+($3284<<2))|0);
9560       var $3286=$3285;
9561       var $3287=$3286;
9562       var $3288=(($3287+4)|0);
9563       HEAPF32[(($3288)>>2)]=$3276;
9564       var $3289=$2;
9565       var $3290=(($3289+64)|0);
9566       var $3291=HEAP32[(($3290)>>2)];
9567       var $3292=$st;
9568       var $3293=(($3292+2)|0);
9569       var $3294=$3293;
9570       var $3295=HEAP16[(($3294)>>1)];
9571       var $3296=(($3295)&65535);
9572       var $3297=(($3291+($3296<<2))|0);
9573       var $3298=$3297;
9574       var $3299=$3298;
9575       var $3300=HEAPF32[(($3299)>>2)];
9576       var $3301=$2;
9577       var $3302=(($3301+64)|0);
9578       var $3303=HEAP32[(($3302)>>2)];
9579       var $3304=$st;
9580       var $3305=(($3304+4)|0);
9581       var $3306=$3305;
9582       var $3307=HEAP16[(($3306)>>1)];
9583       var $3308=(($3307)&65535);
9584       var $3309=(($3303+($3308<<2))|0);
9585       var $3310=$3309;
9586       var $3311=$3310;
9587       var $3312=(($3311+8)|0);
9588       var $3313=HEAPF32[(($3312)>>2)];
9589       var $3314=($3300)*($3313);
9590       var $3315=$2;
9591       var $3316=(($3315+64)|0);
9592       var $3317=HEAP32[(($3316)>>2)];
9593       var $3318=$st;
9594       var $3319=(($3318+6)|0);
9595       var $3320=$3319;
9596       var $3321=HEAP16[(($3320)>>1)];
9597       var $3322=(($3321)&65535);
9598       var $3323=(($3317+($3322<<2))|0);
9599       var $3324=$3323;
9600       var $3325=$3324;
9601       var $3326=(($3325+8)|0);
9602       HEAPF32[(($3326)>>2)]=$3314;
9603       __label__ = 245; break;
9604     case 134:
9605       var $3328=$2;
9606       var $3329=(($3328+64)|0);
9607       var $3330=HEAP32[(($3329)>>2)];
9608       var $3331=$st;
9609       var $3332=(($3331+4)|0);
9610       var $3333=$3332;
9611       var $3334=HEAP16[(($3333)>>1)];
9612       var $3335=(($3334)&65535);
9613       var $3336=(($3330+($3335<<2))|0);
9614       var $3337=$3336;
9615       var $3338=$3337;
9616       var $3339=HEAPF32[(($3338)>>2)];
9617       var $3340=$2;
9618       var $3341=(($3340+64)|0);
9619       var $3342=HEAP32[(($3341)>>2)];
9620       var $3343=$st;
9621       var $3344=(($3343+2)|0);
9622       var $3345=$3344;
9623       var $3346=HEAP16[(($3345)>>1)];
9624       var $3347=(($3346)&65535);
9625       var $3348=(($3342+($3347<<2))|0);
9626       var $3349=$3348;
9627       var $3350=$3349;
9628       var $3351=(($3350)|0);
9629       var $3352=HEAPF32[(($3351)>>2)];
9630       var $3353=($3339)*($3352);
9631       var $3354=$2;
9632       var $3355=(($3354+64)|0);
9633       var $3356=HEAP32[(($3355)>>2)];
9634       var $3357=$st;
9635       var $3358=(($3357+6)|0);
9636       var $3359=$3358;
9637       var $3360=HEAP16[(($3359)>>1)];
9638       var $3361=(($3360)&65535);
9639       var $3362=(($3356+($3361<<2))|0);
9640       var $3363=$3362;
9641       var $3364=$3363;
9642       var $3365=(($3364)|0);
9643       HEAPF32[(($3365)>>2)]=$3353;
9644       var $3366=$2;
9645       var $3367=(($3366+64)|0);
9646       var $3368=HEAP32[(($3367)>>2)];
9647       var $3369=$st;
9648       var $3370=(($3369+4)|0);
9649       var $3371=$3370;
9650       var $3372=HEAP16[(($3371)>>1)];
9651       var $3373=(($3372)&65535);
9652       var $3374=(($3368+($3373<<2))|0);
9653       var $3375=$3374;
9654       var $3376=$3375;
9655       var $3377=HEAPF32[(($3376)>>2)];
9656       var $3378=$2;
9657       var $3379=(($3378+64)|0);
9658       var $3380=HEAP32[(($3379)>>2)];
9659       var $3381=$st;
9660       var $3382=(($3381+2)|0);
9661       var $3383=$3382;
9662       var $3384=HEAP16[(($3383)>>1)];
9663       var $3385=(($3384)&65535);
9664       var $3386=(($3380+($3385<<2))|0);
9665       var $3387=$3386;
9666       var $3388=$3387;
9667       var $3389=(($3388+4)|0);
9668       var $3390=HEAPF32[(($3389)>>2)];
9669       var $3391=($3377)*($3390);
9670       var $3392=$2;
9671       var $3393=(($3392+64)|0);
9672       var $3394=HEAP32[(($3393)>>2)];
9673       var $3395=$st;
9674       var $3396=(($3395+6)|0);
9675       var $3397=$3396;
9676       var $3398=HEAP16[(($3397)>>1)];
9677       var $3399=(($3398)&65535);
9678       var $3400=(($3394+($3399<<2))|0);
9679       var $3401=$3400;
9680       var $3402=$3401;
9681       var $3403=(($3402+4)|0);
9682       HEAPF32[(($3403)>>2)]=$3391;
9683       var $3404=$2;
9684       var $3405=(($3404+64)|0);
9685       var $3406=HEAP32[(($3405)>>2)];
9686       var $3407=$st;
9687       var $3408=(($3407+4)|0);
9688       var $3409=$3408;
9689       var $3410=HEAP16[(($3409)>>1)];
9690       var $3411=(($3410)&65535);
9691       var $3412=(($3406+($3411<<2))|0);
9692       var $3413=$3412;
9693       var $3414=$3413;
9694       var $3415=HEAPF32[(($3414)>>2)];
9695       var $3416=$2;
9696       var $3417=(($3416+64)|0);
9697       var $3418=HEAP32[(($3417)>>2)];
9698       var $3419=$st;
9699       var $3420=(($3419+2)|0);
9700       var $3421=$3420;
9701       var $3422=HEAP16[(($3421)>>1)];
9702       var $3423=(($3422)&65535);
9703       var $3424=(($3418+($3423<<2))|0);
9704       var $3425=$3424;
9705       var $3426=$3425;
9706       var $3427=(($3426+8)|0);
9707       var $3428=HEAPF32[(($3427)>>2)];
9708       var $3429=($3415)*($3428);
9709       var $3430=$2;
9710       var $3431=(($3430+64)|0);
9711       var $3432=HEAP32[(($3431)>>2)];
9712       var $3433=$st;
9713       var $3434=(($3433+6)|0);
9714       var $3435=$3434;
9715       var $3436=HEAP16[(($3435)>>1)];
9716       var $3437=(($3436)&65535);
9717       var $3438=(($3432+($3437<<2))|0);
9718       var $3439=$3438;
9719       var $3440=$3439;
9720       var $3441=(($3440+8)|0);
9721       HEAPF32[(($3441)>>2)]=$3429;
9722       __label__ = 245; break;
9723     case 135:
9724       var $3443=$2;
9725       var $3444=(($3443+64)|0);
9726       var $3445=HEAP32[(($3444)>>2)];
9727       var $3446=$st;
9728       var $3447=(($3446+4)|0);
9729       var $3448=$3447;
9730       var $3449=HEAP16[(($3448)>>1)];
9731       var $3450=(($3449)&65535);
9732       var $3451=(($3445+($3450<<2))|0);
9733       var $3452=$3451;
9734       var $3453=$3452;
9735       var $3454=HEAPF32[(($3453)>>2)];
9736       var $3455=$3454 != 0;
9737       if ($3455) { __label__ = 136; break; } else { __label__ = 137; break; }
9738     case 136:
9739       var $3457=$2;
9740       var $3458=(($3457+64)|0);
9741       var $3459=HEAP32[(($3458)>>2)];
9742       var $3460=$st;
9743       var $3461=(($3460+2)|0);
9744       var $3462=$3461;
9745       var $3463=HEAP16[(($3462)>>1)];
9746       var $3464=(($3463)&65535);
9747       var $3465=(($3459+($3464<<2))|0);
9748       var $3466=$3465;
9749       var $3467=$3466;
9750       var $3468=HEAPF32[(($3467)>>2)];
9751       var $3469=$2;
9752       var $3470=(($3469+64)|0);
9753       var $3471=HEAP32[(($3470)>>2)];
9754       var $3472=$st;
9755       var $3473=(($3472+4)|0);
9756       var $3474=$3473;
9757       var $3475=HEAP16[(($3474)>>1)];
9758       var $3476=(($3475)&65535);
9759       var $3477=(($3471+($3476<<2))|0);
9760       var $3478=$3477;
9761       var $3479=$3478;
9762       var $3480=HEAPF32[(($3479)>>2)];
9763       var $3481=($3468)/($3480);
9764       var $3482=$2;
9765       var $3483=(($3482+64)|0);
9766       var $3484=HEAP32[(($3483)>>2)];
9767       var $3485=$st;
9768       var $3486=(($3485+6)|0);
9769       var $3487=$3486;
9770       var $3488=HEAP16[(($3487)>>1)];
9771       var $3489=(($3488)&65535);
9772       var $3490=(($3484+($3489<<2))|0);
9773       var $3491=$3490;
9774       var $3492=$3491;
9775       HEAPF32[(($3492)>>2)]=$3481;
9776       __label__ = 138; break;
9777     case 137:
9778       var $3494=$2;
9779       var $3495=(($3494+64)|0);
9780       var $3496=HEAP32[(($3495)>>2)];
9781       var $3497=$st;
9782       var $3498=(($3497+6)|0);
9783       var $3499=$3498;
9784       var $3500=HEAP16[(($3499)>>1)];
9785       var $3501=(($3500)&65535);
9786       var $3502=(($3496+($3501<<2))|0);
9787       var $3503=$3502;
9788       var $3504=$3503;
9789       HEAPF32[(($3504)>>2)]=0;
9790       __label__ = 138; break;
9791     case 138:
9792       __label__ = 245; break;
9793     case 139:
9794       var $3507=$2;
9795       var $3508=(($3507+64)|0);
9796       var $3509=HEAP32[(($3508)>>2)];
9797       var $3510=$st;
9798       var $3511=(($3510+2)|0);
9799       var $3512=$3511;
9800       var $3513=HEAP16[(($3512)>>1)];
9801       var $3514=(($3513)&65535);
9802       var $3515=(($3509+($3514<<2))|0);
9803       var $3516=$3515;
9804       var $3517=$3516;
9805       var $3518=HEAPF32[(($3517)>>2)];
9806       var $3519=$2;
9807       var $3520=(($3519+64)|0);
9808       var $3521=HEAP32[(($3520)>>2)];
9809       var $3522=$st;
9810       var $3523=(($3522+4)|0);
9811       var $3524=$3523;
9812       var $3525=HEAP16[(($3524)>>1)];
9813       var $3526=(($3525)&65535);
9814       var $3527=(($3521+($3526<<2))|0);
9815       var $3528=$3527;
9816       var $3529=$3528;
9817       var $3530=HEAPF32[(($3529)>>2)];
9818       var $3531=($3518)+($3530);
9819       var $3532=$2;
9820       var $3533=(($3532+64)|0);
9821       var $3534=HEAP32[(($3533)>>2)];
9822       var $3535=$st;
9823       var $3536=(($3535+6)|0);
9824       var $3537=$3536;
9825       var $3538=HEAP16[(($3537)>>1)];
9826       var $3539=(($3538)&65535);
9827       var $3540=(($3534+($3539<<2))|0);
9828       var $3541=$3540;
9829       var $3542=$3541;
9830       HEAPF32[(($3542)>>2)]=$3531;
9831       __label__ = 245; break;
9832     case 140:
9833       var $3544=$2;
9834       var $3545=(($3544+64)|0);
9835       var $3546=HEAP32[(($3545)>>2)];
9836       var $3547=$st;
9837       var $3548=(($3547+2)|0);
9838       var $3549=$3548;
9839       var $3550=HEAP16[(($3549)>>1)];
9840       var $3551=(($3550)&65535);
9841       var $3552=(($3546+($3551<<2))|0);
9842       var $3553=$3552;
9843       var $3554=$3553;
9844       var $3555=(($3554)|0);
9845       var $3556=HEAPF32[(($3555)>>2)];
9846       var $3557=$2;
9847       var $3558=(($3557+64)|0);
9848       var $3559=HEAP32[(($3558)>>2)];
9849       var $3560=$st;
9850       var $3561=(($3560+4)|0);
9851       var $3562=$3561;
9852       var $3563=HEAP16[(($3562)>>1)];
9853       var $3564=(($3563)&65535);
9854       var $3565=(($3559+($3564<<2))|0);
9855       var $3566=$3565;
9856       var $3567=$3566;
9857       var $3568=(($3567)|0);
9858       var $3569=HEAPF32[(($3568)>>2)];
9859       var $3570=($3556)+($3569);
9860       var $3571=$2;
9861       var $3572=(($3571+64)|0);
9862       var $3573=HEAP32[(($3572)>>2)];
9863       var $3574=$st;
9864       var $3575=(($3574+6)|0);
9865       var $3576=$3575;
9866       var $3577=HEAP16[(($3576)>>1)];
9867       var $3578=(($3577)&65535);
9868       var $3579=(($3573+($3578<<2))|0);
9869       var $3580=$3579;
9870       var $3581=$3580;
9871       var $3582=(($3581)|0);
9872       HEAPF32[(($3582)>>2)]=$3570;
9873       var $3583=$2;
9874       var $3584=(($3583+64)|0);
9875       var $3585=HEAP32[(($3584)>>2)];
9876       var $3586=$st;
9877       var $3587=(($3586+2)|0);
9878       var $3588=$3587;
9879       var $3589=HEAP16[(($3588)>>1)];
9880       var $3590=(($3589)&65535);
9881       var $3591=(($3585+($3590<<2))|0);
9882       var $3592=$3591;
9883       var $3593=$3592;
9884       var $3594=(($3593+4)|0);
9885       var $3595=HEAPF32[(($3594)>>2)];
9886       var $3596=$2;
9887       var $3597=(($3596+64)|0);
9888       var $3598=HEAP32[(($3597)>>2)];
9889       var $3599=$st;
9890       var $3600=(($3599+4)|0);
9891       var $3601=$3600;
9892       var $3602=HEAP16[(($3601)>>1)];
9893       var $3603=(($3602)&65535);
9894       var $3604=(($3598+($3603<<2))|0);
9895       var $3605=$3604;
9896       var $3606=$3605;
9897       var $3607=(($3606+4)|0);
9898       var $3608=HEAPF32[(($3607)>>2)];
9899       var $3609=($3595)+($3608);
9900       var $3610=$2;
9901       var $3611=(($3610+64)|0);
9902       var $3612=HEAP32[(($3611)>>2)];
9903       var $3613=$st;
9904       var $3614=(($3613+6)|0);
9905       var $3615=$3614;
9906       var $3616=HEAP16[(($3615)>>1)];
9907       var $3617=(($3616)&65535);
9908       var $3618=(($3612+($3617<<2))|0);
9909       var $3619=$3618;
9910       var $3620=$3619;
9911       var $3621=(($3620+4)|0);
9912       HEAPF32[(($3621)>>2)]=$3609;
9913       var $3622=$2;
9914       var $3623=(($3622+64)|0);
9915       var $3624=HEAP32[(($3623)>>2)];
9916       var $3625=$st;
9917       var $3626=(($3625+2)|0);
9918       var $3627=$3626;
9919       var $3628=HEAP16[(($3627)>>1)];
9920       var $3629=(($3628)&65535);
9921       var $3630=(($3624+($3629<<2))|0);
9922       var $3631=$3630;
9923       var $3632=$3631;
9924       var $3633=(($3632+8)|0);
9925       var $3634=HEAPF32[(($3633)>>2)];
9926       var $3635=$2;
9927       var $3636=(($3635+64)|0);
9928       var $3637=HEAP32[(($3636)>>2)];
9929       var $3638=$st;
9930       var $3639=(($3638+4)|0);
9931       var $3640=$3639;
9932       var $3641=HEAP16[(($3640)>>1)];
9933       var $3642=(($3641)&65535);
9934       var $3643=(($3637+($3642<<2))|0);
9935       var $3644=$3643;
9936       var $3645=$3644;
9937       var $3646=(($3645+8)|0);
9938       var $3647=HEAPF32[(($3646)>>2)];
9939       var $3648=($3634)+($3647);
9940       var $3649=$2;
9941       var $3650=(($3649+64)|0);
9942       var $3651=HEAP32[(($3650)>>2)];
9943       var $3652=$st;
9944       var $3653=(($3652+6)|0);
9945       var $3654=$3653;
9946       var $3655=HEAP16[(($3654)>>1)];
9947       var $3656=(($3655)&65535);
9948       var $3657=(($3651+($3656<<2))|0);
9949       var $3658=$3657;
9950       var $3659=$3658;
9951       var $3660=(($3659+8)|0);
9952       HEAPF32[(($3660)>>2)]=$3648;
9953       __label__ = 245; break;
9954     case 141:
9955       var $3662=$2;
9956       var $3663=(($3662+64)|0);
9957       var $3664=HEAP32[(($3663)>>2)];
9958       var $3665=$st;
9959       var $3666=(($3665+2)|0);
9960       var $3667=$3666;
9961       var $3668=HEAP16[(($3667)>>1)];
9962       var $3669=(($3668)&65535);
9963       var $3670=(($3664+($3669<<2))|0);
9964       var $3671=$3670;
9965       var $3672=$3671;
9966       var $3673=HEAPF32[(($3672)>>2)];
9967       var $3674=$2;
9968       var $3675=(($3674+64)|0);
9969       var $3676=HEAP32[(($3675)>>2)];
9970       var $3677=$st;
9971       var $3678=(($3677+4)|0);
9972       var $3679=$3678;
9973       var $3680=HEAP16[(($3679)>>1)];
9974       var $3681=(($3680)&65535);
9975       var $3682=(($3676+($3681<<2))|0);
9976       var $3683=$3682;
9977       var $3684=$3683;
9978       var $3685=HEAPF32[(($3684)>>2)];
9979       var $3686=($3673)-($3685);
9980       var $3687=$2;
9981       var $3688=(($3687+64)|0);
9982       var $3689=HEAP32[(($3688)>>2)];
9983       var $3690=$st;
9984       var $3691=(($3690+6)|0);
9985       var $3692=$3691;
9986       var $3693=HEAP16[(($3692)>>1)];
9987       var $3694=(($3693)&65535);
9988       var $3695=(($3689+($3694<<2))|0);
9989       var $3696=$3695;
9990       var $3697=$3696;
9991       HEAPF32[(($3697)>>2)]=$3686;
9992       __label__ = 245; break;
9993     case 142:
9994       var $3699=$2;
9995       var $3700=(($3699+64)|0);
9996       var $3701=HEAP32[(($3700)>>2)];
9997       var $3702=$st;
9998       var $3703=(($3702+2)|0);
9999       var $3704=$3703;
10000       var $3705=HEAP16[(($3704)>>1)];
10001       var $3706=(($3705)&65535);
10002       var $3707=(($3701+($3706<<2))|0);
10003       var $3708=$3707;
10004       var $3709=$3708;
10005       var $3710=(($3709)|0);
10006       var $3711=HEAPF32[(($3710)>>2)];
10007       var $3712=$2;
10008       var $3713=(($3712+64)|0);
10009       var $3714=HEAP32[(($3713)>>2)];
10010       var $3715=$st;
10011       var $3716=(($3715+4)|0);
10012       var $3717=$3716;
10013       var $3718=HEAP16[(($3717)>>1)];
10014       var $3719=(($3718)&65535);
10015       var $3720=(($3714+($3719<<2))|0);
10016       var $3721=$3720;
10017       var $3722=$3721;
10018       var $3723=(($3722)|0);
10019       var $3724=HEAPF32[(($3723)>>2)];
10020       var $3725=($3711)-($3724);
10021       var $3726=$2;
10022       var $3727=(($3726+64)|0);
10023       var $3728=HEAP32[(($3727)>>2)];
10024       var $3729=$st;
10025       var $3730=(($3729+6)|0);
10026       var $3731=$3730;
10027       var $3732=HEAP16[(($3731)>>1)];
10028       var $3733=(($3732)&65535);
10029       var $3734=(($3728+($3733<<2))|0);
10030       var $3735=$3734;
10031       var $3736=$3735;
10032       var $3737=(($3736)|0);
10033       HEAPF32[(($3737)>>2)]=$3725;
10034       var $3738=$2;
10035       var $3739=(($3738+64)|0);
10036       var $3740=HEAP32[(($3739)>>2)];
10037       var $3741=$st;
10038       var $3742=(($3741+2)|0);
10039       var $3743=$3742;
10040       var $3744=HEAP16[(($3743)>>1)];
10041       var $3745=(($3744)&65535);
10042       var $3746=(($3740+($3745<<2))|0);
10043       var $3747=$3746;
10044       var $3748=$3747;
10045       var $3749=(($3748+4)|0);
10046       var $3750=HEAPF32[(($3749)>>2)];
10047       var $3751=$2;
10048       var $3752=(($3751+64)|0);
10049       var $3753=HEAP32[(($3752)>>2)];
10050       var $3754=$st;
10051       var $3755=(($3754+4)|0);
10052       var $3756=$3755;
10053       var $3757=HEAP16[(($3756)>>1)];
10054       var $3758=(($3757)&65535);
10055       var $3759=(($3753+($3758<<2))|0);
10056       var $3760=$3759;
10057       var $3761=$3760;
10058       var $3762=(($3761+4)|0);
10059       var $3763=HEAPF32[(($3762)>>2)];
10060       var $3764=($3750)-($3763);
10061       var $3765=$2;
10062       var $3766=(($3765+64)|0);
10063       var $3767=HEAP32[(($3766)>>2)];
10064       var $3768=$st;
10065       var $3769=(($3768+6)|0);
10066       var $3770=$3769;
10067       var $3771=HEAP16[(($3770)>>1)];
10068       var $3772=(($3771)&65535);
10069       var $3773=(($3767+($3772<<2))|0);
10070       var $3774=$3773;
10071       var $3775=$3774;
10072       var $3776=(($3775+4)|0);
10073       HEAPF32[(($3776)>>2)]=$3764;
10074       var $3777=$2;
10075       var $3778=(($3777+64)|0);
10076       var $3779=HEAP32[(($3778)>>2)];
10077       var $3780=$st;
10078       var $3781=(($3780+2)|0);
10079       var $3782=$3781;
10080       var $3783=HEAP16[(($3782)>>1)];
10081       var $3784=(($3783)&65535);
10082       var $3785=(($3779+($3784<<2))|0);
10083       var $3786=$3785;
10084       var $3787=$3786;
10085       var $3788=(($3787+8)|0);
10086       var $3789=HEAPF32[(($3788)>>2)];
10087       var $3790=$2;
10088       var $3791=(($3790+64)|0);
10089       var $3792=HEAP32[(($3791)>>2)];
10090       var $3793=$st;
10091       var $3794=(($3793+4)|0);
10092       var $3795=$3794;
10093       var $3796=HEAP16[(($3795)>>1)];
10094       var $3797=(($3796)&65535);
10095       var $3798=(($3792+($3797<<2))|0);
10096       var $3799=$3798;
10097       var $3800=$3799;
10098       var $3801=(($3800+8)|0);
10099       var $3802=HEAPF32[(($3801)>>2)];
10100       var $3803=($3789)-($3802);
10101       var $3804=$2;
10102       var $3805=(($3804+64)|0);
10103       var $3806=HEAP32[(($3805)>>2)];
10104       var $3807=$st;
10105       var $3808=(($3807+6)|0);
10106       var $3809=$3808;
10107       var $3810=HEAP16[(($3809)>>1)];
10108       var $3811=(($3810)&65535);
10109       var $3812=(($3806+($3811<<2))|0);
10110       var $3813=$3812;
10111       var $3814=$3813;
10112       var $3815=(($3814+8)|0);
10113       HEAPF32[(($3815)>>2)]=$3803;
10114       __label__ = 245; break;
10115     case 143:
10116       var $3817=$2;
10117       var $3818=(($3817+64)|0);
10118       var $3819=HEAP32[(($3818)>>2)];
10119       var $3820=$st;
10120       var $3821=(($3820+2)|0);
10121       var $3822=$3821;
10122       var $3823=HEAP16[(($3822)>>1)];
10123       var $3824=(($3823)&65535);
10124       var $3825=(($3819+($3824<<2))|0);
10125       var $3826=$3825;
10126       var $3827=$3826;
10127       var $3828=HEAPF32[(($3827)>>2)];
10128       var $3829=$2;
10129       var $3830=(($3829+64)|0);
10130       var $3831=HEAP32[(($3830)>>2)];
10131       var $3832=$st;
10132       var $3833=(($3832+4)|0);
10133       var $3834=$3833;
10134       var $3835=HEAP16[(($3834)>>1)];
10135       var $3836=(($3835)&65535);
10136       var $3837=(($3831+($3836<<2))|0);
10137       var $3838=$3837;
10138       var $3839=$3838;
10139       var $3840=HEAPF32[(($3839)>>2)];
10140       var $3841=$3828 == $3840;
10141       var $3842=(($3841)&1);
10142       var $3843=(($3842)|0);
10143       var $3844=$2;
10144       var $3845=(($3844+64)|0);
10145       var $3846=HEAP32[(($3845)>>2)];
10146       var $3847=$st;
10147       var $3848=(($3847+6)|0);
10148       var $3849=$3848;
10149       var $3850=HEAP16[(($3849)>>1)];
10150       var $3851=(($3850)&65535);
10151       var $3852=(($3846+($3851<<2))|0);
10152       var $3853=$3852;
10153       var $3854=$3853;
10154       HEAPF32[(($3854)>>2)]=$3843;
10155       __label__ = 245; break;
10156     case 144:
10157       var $3856=$2;
10158       var $3857=(($3856+64)|0);
10159       var $3858=HEAP32[(($3857)>>2)];
10160       var $3859=$st;
10161       var $3860=(($3859+2)|0);
10162       var $3861=$3860;
10163       var $3862=HEAP16[(($3861)>>1)];
10164       var $3863=(($3862)&65535);
10165       var $3864=(($3858+($3863<<2))|0);
10166       var $3865=$3864;
10167       var $3866=$3865;
10168       var $3867=(($3866)|0);
10169       var $3868=HEAPF32[(($3867)>>2)];
10170       var $3869=$2;
10171       var $3870=(($3869+64)|0);
10172       var $3871=HEAP32[(($3870)>>2)];
10173       var $3872=$st;
10174       var $3873=(($3872+4)|0);
10175       var $3874=$3873;
10176       var $3875=HEAP16[(($3874)>>1)];
10177       var $3876=(($3875)&65535);
10178       var $3877=(($3871+($3876<<2))|0);
10179       var $3878=$3877;
10180       var $3879=$3878;
10181       var $3880=(($3879)|0);
10182       var $3881=HEAPF32[(($3880)>>2)];
10183       var $3882=$3868 == $3881;
10184       if ($3882) { __label__ = 145; break; } else { var $3940 = 0;__label__ = 147; break; }
10185     case 145:
10186       var $3884=$2;
10187       var $3885=(($3884+64)|0);
10188       var $3886=HEAP32[(($3885)>>2)];
10189       var $3887=$st;
10190       var $3888=(($3887+2)|0);
10191       var $3889=$3888;
10192       var $3890=HEAP16[(($3889)>>1)];
10193       var $3891=(($3890)&65535);
10194       var $3892=(($3886+($3891<<2))|0);
10195       var $3893=$3892;
10196       var $3894=$3893;
10197       var $3895=(($3894+4)|0);
10198       var $3896=HEAPF32[(($3895)>>2)];
10199       var $3897=$2;
10200       var $3898=(($3897+64)|0);
10201       var $3899=HEAP32[(($3898)>>2)];
10202       var $3900=$st;
10203       var $3901=(($3900+4)|0);
10204       var $3902=$3901;
10205       var $3903=HEAP16[(($3902)>>1)];
10206       var $3904=(($3903)&65535);
10207       var $3905=(($3899+($3904<<2))|0);
10208       var $3906=$3905;
10209       var $3907=$3906;
10210       var $3908=(($3907+4)|0);
10211       var $3909=HEAPF32[(($3908)>>2)];
10212       var $3910=$3896 == $3909;
10213       if ($3910) { __label__ = 146; break; } else { var $3940 = 0;__label__ = 147; break; }
10214     case 146:
10215       var $3912=$2;
10216       var $3913=(($3912+64)|0);
10217       var $3914=HEAP32[(($3913)>>2)];
10218       var $3915=$st;
10219       var $3916=(($3915+2)|0);
10220       var $3917=$3916;
10221       var $3918=HEAP16[(($3917)>>1)];
10222       var $3919=(($3918)&65535);
10223       var $3920=(($3914+($3919<<2))|0);
10224       var $3921=$3920;
10225       var $3922=$3921;
10226       var $3923=(($3922+8)|0);
10227       var $3924=HEAPF32[(($3923)>>2)];
10228       var $3925=$2;
10229       var $3926=(($3925+64)|0);
10230       var $3927=HEAP32[(($3926)>>2)];
10231       var $3928=$st;
10232       var $3929=(($3928+4)|0);
10233       var $3930=$3929;
10234       var $3931=HEAP16[(($3930)>>1)];
10235       var $3932=(($3931)&65535);
10236       var $3933=(($3927+($3932<<2))|0);
10237       var $3934=$3933;
10238       var $3935=$3934;
10239       var $3936=(($3935+8)|0);
10240       var $3937=HEAPF32[(($3936)>>2)];
10241       var $3938=$3924 == $3937;
10242       var $3940 = $3938;__label__ = 147; break;
10243     case 147:
10244       var $3940;
10245       var $3941=(($3940)&1);
10246       var $3942=(($3941)|0);
10247       var $3943=$2;
10248       var $3944=(($3943+64)|0);
10249       var $3945=HEAP32[(($3944)>>2)];
10250       var $3946=$st;
10251       var $3947=(($3946+6)|0);
10252       var $3948=$3947;
10253       var $3949=HEAP16[(($3948)>>1)];
10254       var $3950=(($3949)&65535);
10255       var $3951=(($3945+($3950<<2))|0);
10256       var $3952=$3951;
10257       var $3953=$3952;
10258       HEAPF32[(($3953)>>2)]=$3942;
10259       __label__ = 245; break;
10260     case 148:
10261       var $3955=$2;
10262       var $3956=$2;
10263       var $3957=(($3956+64)|0);
10264       var $3958=HEAP32[(($3957)>>2)];
10265       var $3959=$st;
10266       var $3960=(($3959+2)|0);
10267       var $3961=$3960;
10268       var $3962=HEAP16[(($3961)>>1)];
10269       var $3963=(($3962)&65535);
10270       var $3964=(($3958+($3963<<2))|0);
10271       var $3965=$3964;
10272       var $3966=$3965;
10273       var $3967=HEAP32[(($3966)>>2)];
10274       var $3968=_prog_getstring($3955, $3967);
10275       var $3969=$2;
10276       var $3970=$2;
10277       var $3971=(($3970+64)|0);
10278       var $3972=HEAP32[(($3971)>>2)];
10279       var $3973=$st;
10280       var $3974=(($3973+4)|0);
10281       var $3975=$3974;
10282       var $3976=HEAP16[(($3975)>>1)];
10283       var $3977=(($3976)&65535);
10284       var $3978=(($3972+($3977<<2))|0);
10285       var $3979=$3978;
10286       var $3980=$3979;
10287       var $3981=HEAP32[(($3980)>>2)];
10288       var $3982=_prog_getstring($3969, $3981);
10289       var $3983=_strcmp($3968, $3982);
10290       var $3984=(($3983)|0)!=0;
10291       var $3985=$3984 ^ 1;
10292       var $3986=(($3985)&1);
10293       var $3987=(($3986)|0);
10294       var $3988=$2;
10295       var $3989=(($3988+64)|0);
10296       var $3990=HEAP32[(($3989)>>2)];
10297       var $3991=$st;
10298       var $3992=(($3991+6)|0);
10299       var $3993=$3992;
10300       var $3994=HEAP16[(($3993)>>1)];
10301       var $3995=(($3994)&65535);
10302       var $3996=(($3990+($3995<<2))|0);
10303       var $3997=$3996;
10304       var $3998=$3997;
10305       HEAPF32[(($3998)>>2)]=$3987;
10306       __label__ = 245; break;
10307     case 149:
10308       var $4000=$2;
10309       var $4001=(($4000+64)|0);
10310       var $4002=HEAP32[(($4001)>>2)];
10311       var $4003=$st;
10312       var $4004=(($4003+2)|0);
10313       var $4005=$4004;
10314       var $4006=HEAP16[(($4005)>>1)];
10315       var $4007=(($4006)&65535);
10316       var $4008=(($4002+($4007<<2))|0);
10317       var $4009=$4008;
10318       var $4010=$4009;
10319       var $4011=HEAP32[(($4010)>>2)];
10320       var $4012=$2;
10321       var $4013=(($4012+64)|0);
10322       var $4014=HEAP32[(($4013)>>2)];
10323       var $4015=$st;
10324       var $4016=(($4015+4)|0);
10325       var $4017=$4016;
10326       var $4018=HEAP16[(($4017)>>1)];
10327       var $4019=(($4018)&65535);
10328       var $4020=(($4014+($4019<<2))|0);
10329       var $4021=$4020;
10330       var $4022=$4021;
10331       var $4023=HEAP32[(($4022)>>2)];
10332       var $4024=(($4011)|0)==(($4023)|0);
10333       var $4025=(($4024)&1);
10334       var $4026=(($4025)|0);
10335       var $4027=$2;
10336       var $4028=(($4027+64)|0);
10337       var $4029=HEAP32[(($4028)>>2)];
10338       var $4030=$st;
10339       var $4031=(($4030+6)|0);
10340       var $4032=$4031;
10341       var $4033=HEAP16[(($4032)>>1)];
10342       var $4034=(($4033)&65535);
10343       var $4035=(($4029+($4034<<2))|0);
10344       var $4036=$4035;
10345       var $4037=$4036;
10346       HEAPF32[(($4037)>>2)]=$4026;
10347       __label__ = 245; break;
10348     case 150:
10349       var $4039=$2;
10350       var $4040=(($4039+64)|0);
10351       var $4041=HEAP32[(($4040)>>2)];
10352       var $4042=$st;
10353       var $4043=(($4042+2)|0);
10354       var $4044=$4043;
10355       var $4045=HEAP16[(($4044)>>1)];
10356       var $4046=(($4045)&65535);
10357       var $4047=(($4041+($4046<<2))|0);
10358       var $4048=$4047;
10359       var $4049=$4048;
10360       var $4050=HEAP32[(($4049)>>2)];
10361       var $4051=$2;
10362       var $4052=(($4051+64)|0);
10363       var $4053=HEAP32[(($4052)>>2)];
10364       var $4054=$st;
10365       var $4055=(($4054+4)|0);
10366       var $4056=$4055;
10367       var $4057=HEAP16[(($4056)>>1)];
10368       var $4058=(($4057)&65535);
10369       var $4059=(($4053+($4058<<2))|0);
10370       var $4060=$4059;
10371       var $4061=$4060;
10372       var $4062=HEAP32[(($4061)>>2)];
10373       var $4063=(($4050)|0)==(($4062)|0);
10374       var $4064=(($4063)&1);
10375       var $4065=(($4064)|0);
10376       var $4066=$2;
10377       var $4067=(($4066+64)|0);
10378       var $4068=HEAP32[(($4067)>>2)];
10379       var $4069=$st;
10380       var $4070=(($4069+6)|0);
10381       var $4071=$4070;
10382       var $4072=HEAP16[(($4071)>>1)];
10383       var $4073=(($4072)&65535);
10384       var $4074=(($4068+($4073<<2))|0);
10385       var $4075=$4074;
10386       var $4076=$4075;
10387       HEAPF32[(($4076)>>2)]=$4065;
10388       __label__ = 245; break;
10389     case 151:
10390       var $4078=$2;
10391       var $4079=(($4078+64)|0);
10392       var $4080=HEAP32[(($4079)>>2)];
10393       var $4081=$st;
10394       var $4082=(($4081+2)|0);
10395       var $4083=$4082;
10396       var $4084=HEAP16[(($4083)>>1)];
10397       var $4085=(($4084)&65535);
10398       var $4086=(($4080+($4085<<2))|0);
10399       var $4087=$4086;
10400       var $4088=$4087;
10401       var $4089=HEAPF32[(($4088)>>2)];
10402       var $4090=$2;
10403       var $4091=(($4090+64)|0);
10404       var $4092=HEAP32[(($4091)>>2)];
10405       var $4093=$st;
10406       var $4094=(($4093+4)|0);
10407       var $4095=$4094;
10408       var $4096=HEAP16[(($4095)>>1)];
10409       var $4097=(($4096)&65535);
10410       var $4098=(($4092+($4097<<2))|0);
10411       var $4099=$4098;
10412       var $4100=$4099;
10413       var $4101=HEAPF32[(($4100)>>2)];
10414       var $4102=$4089 != $4101;
10415       var $4103=(($4102)&1);
10416       var $4104=(($4103)|0);
10417       var $4105=$2;
10418       var $4106=(($4105+64)|0);
10419       var $4107=HEAP32[(($4106)>>2)];
10420       var $4108=$st;
10421       var $4109=(($4108+6)|0);
10422       var $4110=$4109;
10423       var $4111=HEAP16[(($4110)>>1)];
10424       var $4112=(($4111)&65535);
10425       var $4113=(($4107+($4112<<2))|0);
10426       var $4114=$4113;
10427       var $4115=$4114;
10428       HEAPF32[(($4115)>>2)]=$4104;
10429       __label__ = 245; break;
10430     case 152:
10431       var $4117=$2;
10432       var $4118=(($4117+64)|0);
10433       var $4119=HEAP32[(($4118)>>2)];
10434       var $4120=$st;
10435       var $4121=(($4120+2)|0);
10436       var $4122=$4121;
10437       var $4123=HEAP16[(($4122)>>1)];
10438       var $4124=(($4123)&65535);
10439       var $4125=(($4119+($4124<<2))|0);
10440       var $4126=$4125;
10441       var $4127=$4126;
10442       var $4128=(($4127)|0);
10443       var $4129=HEAPF32[(($4128)>>2)];
10444       var $4130=$2;
10445       var $4131=(($4130+64)|0);
10446       var $4132=HEAP32[(($4131)>>2)];
10447       var $4133=$st;
10448       var $4134=(($4133+4)|0);
10449       var $4135=$4134;
10450       var $4136=HEAP16[(($4135)>>1)];
10451       var $4137=(($4136)&65535);
10452       var $4138=(($4132+($4137<<2))|0);
10453       var $4139=$4138;
10454       var $4140=$4139;
10455       var $4141=(($4140)|0);
10456       var $4142=HEAPF32[(($4141)>>2)];
10457       var $4143=$4129 != $4142;
10458       if ($4143) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 153; break; }
10459     case 153:
10460       var $4145=$2;
10461       var $4146=(($4145+64)|0);
10462       var $4147=HEAP32[(($4146)>>2)];
10463       var $4148=$st;
10464       var $4149=(($4148+2)|0);
10465       var $4150=$4149;
10466       var $4151=HEAP16[(($4150)>>1)];
10467       var $4152=(($4151)&65535);
10468       var $4153=(($4147+($4152<<2))|0);
10469       var $4154=$4153;
10470       var $4155=$4154;
10471       var $4156=(($4155+4)|0);
10472       var $4157=HEAPF32[(($4156)>>2)];
10473       var $4158=$2;
10474       var $4159=(($4158+64)|0);
10475       var $4160=HEAP32[(($4159)>>2)];
10476       var $4161=$st;
10477       var $4162=(($4161+4)|0);
10478       var $4163=$4162;
10479       var $4164=HEAP16[(($4163)>>1)];
10480       var $4165=(($4164)&65535);
10481       var $4166=(($4160+($4165<<2))|0);
10482       var $4167=$4166;
10483       var $4168=$4167;
10484       var $4169=(($4168+4)|0);
10485       var $4170=HEAPF32[(($4169)>>2)];
10486       var $4171=$4157 != $4170;
10487       if ($4171) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 154; break; }
10488     case 154:
10489       var $4173=$2;
10490       var $4174=(($4173+64)|0);
10491       var $4175=HEAP32[(($4174)>>2)];
10492       var $4176=$st;
10493       var $4177=(($4176+2)|0);
10494       var $4178=$4177;
10495       var $4179=HEAP16[(($4178)>>1)];
10496       var $4180=(($4179)&65535);
10497       var $4181=(($4175+($4180<<2))|0);
10498       var $4182=$4181;
10499       var $4183=$4182;
10500       var $4184=(($4183+8)|0);
10501       var $4185=HEAPF32[(($4184)>>2)];
10502       var $4186=$2;
10503       var $4187=(($4186+64)|0);
10504       var $4188=HEAP32[(($4187)>>2)];
10505       var $4189=$st;
10506       var $4190=(($4189+4)|0);
10507       var $4191=$4190;
10508       var $4192=HEAP16[(($4191)>>1)];
10509       var $4193=(($4192)&65535);
10510       var $4194=(($4188+($4193<<2))|0);
10511       var $4195=$4194;
10512       var $4196=$4195;
10513       var $4197=(($4196+8)|0);
10514       var $4198=HEAPF32[(($4197)>>2)];
10515       var $4199=$4185 != $4198;
10516       var $4201 = $4199;__label__ = 155; break;
10517     case 155:
10518       var $4201;
10519       var $4202=(($4201)&1);
10520       var $4203=(($4202)|0);
10521       var $4204=$2;
10522       var $4205=(($4204+64)|0);
10523       var $4206=HEAP32[(($4205)>>2)];
10524       var $4207=$st;
10525       var $4208=(($4207+6)|0);
10526       var $4209=$4208;
10527       var $4210=HEAP16[(($4209)>>1)];
10528       var $4211=(($4210)&65535);
10529       var $4212=(($4206+($4211<<2))|0);
10530       var $4213=$4212;
10531       var $4214=$4213;
10532       HEAPF32[(($4214)>>2)]=$4203;
10533       __label__ = 245; break;
10534     case 156:
10535       var $4216=$2;
10536       var $4217=$2;
10537       var $4218=(($4217+64)|0);
10538       var $4219=HEAP32[(($4218)>>2)];
10539       var $4220=$st;
10540       var $4221=(($4220+2)|0);
10541       var $4222=$4221;
10542       var $4223=HEAP16[(($4222)>>1)];
10543       var $4224=(($4223)&65535);
10544       var $4225=(($4219+($4224<<2))|0);
10545       var $4226=$4225;
10546       var $4227=$4226;
10547       var $4228=HEAP32[(($4227)>>2)];
10548       var $4229=_prog_getstring($4216, $4228);
10549       var $4230=$2;
10550       var $4231=$2;
10551       var $4232=(($4231+64)|0);
10552       var $4233=HEAP32[(($4232)>>2)];
10553       var $4234=$st;
10554       var $4235=(($4234+4)|0);
10555       var $4236=$4235;
10556       var $4237=HEAP16[(($4236)>>1)];
10557       var $4238=(($4237)&65535);
10558       var $4239=(($4233+($4238<<2))|0);
10559       var $4240=$4239;
10560       var $4241=$4240;
10561       var $4242=HEAP32[(($4241)>>2)];
10562       var $4243=_prog_getstring($4230, $4242);
10563       var $4244=_strcmp($4229, $4243);
10564       var $4245=(($4244)|0)!=0;
10565       var $4246=$4245 ^ 1;
10566       var $4247=$4246 ^ 1;
10567       var $4248=(($4247)&1);
10568       var $4249=(($4248)|0);
10569       var $4250=$2;
10570       var $4251=(($4250+64)|0);
10571       var $4252=HEAP32[(($4251)>>2)];
10572       var $4253=$st;
10573       var $4254=(($4253+6)|0);
10574       var $4255=$4254;
10575       var $4256=HEAP16[(($4255)>>1)];
10576       var $4257=(($4256)&65535);
10577       var $4258=(($4252+($4257<<2))|0);
10578       var $4259=$4258;
10579       var $4260=$4259;
10580       HEAPF32[(($4260)>>2)]=$4249;
10581       __label__ = 245; break;
10582     case 157:
10583       var $4262=$2;
10584       var $4263=(($4262+64)|0);
10585       var $4264=HEAP32[(($4263)>>2)];
10586       var $4265=$st;
10587       var $4266=(($4265+2)|0);
10588       var $4267=$4266;
10589       var $4268=HEAP16[(($4267)>>1)];
10590       var $4269=(($4268)&65535);
10591       var $4270=(($4264+($4269<<2))|0);
10592       var $4271=$4270;
10593       var $4272=$4271;
10594       var $4273=HEAP32[(($4272)>>2)];
10595       var $4274=$2;
10596       var $4275=(($4274+64)|0);
10597       var $4276=HEAP32[(($4275)>>2)];
10598       var $4277=$st;
10599       var $4278=(($4277+4)|0);
10600       var $4279=$4278;
10601       var $4280=HEAP16[(($4279)>>1)];
10602       var $4281=(($4280)&65535);
10603       var $4282=(($4276+($4281<<2))|0);
10604       var $4283=$4282;
10605       var $4284=$4283;
10606       var $4285=HEAP32[(($4284)>>2)];
10607       var $4286=(($4273)|0)!=(($4285)|0);
10608       var $4287=(($4286)&1);
10609       var $4288=(($4287)|0);
10610       var $4289=$2;
10611       var $4290=(($4289+64)|0);
10612       var $4291=HEAP32[(($4290)>>2)];
10613       var $4292=$st;
10614       var $4293=(($4292+6)|0);
10615       var $4294=$4293;
10616       var $4295=HEAP16[(($4294)>>1)];
10617       var $4296=(($4295)&65535);
10618       var $4297=(($4291+($4296<<2))|0);
10619       var $4298=$4297;
10620       var $4299=$4298;
10621       HEAPF32[(($4299)>>2)]=$4288;
10622       __label__ = 245; break;
10623     case 158:
10624       var $4301=$2;
10625       var $4302=(($4301+64)|0);
10626       var $4303=HEAP32[(($4302)>>2)];
10627       var $4304=$st;
10628       var $4305=(($4304+2)|0);
10629       var $4306=$4305;
10630       var $4307=HEAP16[(($4306)>>1)];
10631       var $4308=(($4307)&65535);
10632       var $4309=(($4303+($4308<<2))|0);
10633       var $4310=$4309;
10634       var $4311=$4310;
10635       var $4312=HEAP32[(($4311)>>2)];
10636       var $4313=$2;
10637       var $4314=(($4313+64)|0);
10638       var $4315=HEAP32[(($4314)>>2)];
10639       var $4316=$st;
10640       var $4317=(($4316+4)|0);
10641       var $4318=$4317;
10642       var $4319=HEAP16[(($4318)>>1)];
10643       var $4320=(($4319)&65535);
10644       var $4321=(($4315+($4320<<2))|0);
10645       var $4322=$4321;
10646       var $4323=$4322;
10647       var $4324=HEAP32[(($4323)>>2)];
10648       var $4325=(($4312)|0)!=(($4324)|0);
10649       var $4326=(($4325)&1);
10650       var $4327=(($4326)|0);
10651       var $4328=$2;
10652       var $4329=(($4328+64)|0);
10653       var $4330=HEAP32[(($4329)>>2)];
10654       var $4331=$st;
10655       var $4332=(($4331+6)|0);
10656       var $4333=$4332;
10657       var $4334=HEAP16[(($4333)>>1)];
10658       var $4335=(($4334)&65535);
10659       var $4336=(($4330+($4335<<2))|0);
10660       var $4337=$4336;
10661       var $4338=$4337;
10662       HEAPF32[(($4338)>>2)]=$4327;
10663       __label__ = 245; break;
10664     case 159:
10665       var $4340=$2;
10666       var $4341=(($4340+64)|0);
10667       var $4342=HEAP32[(($4341)>>2)];
10668       var $4343=$st;
10669       var $4344=(($4343+2)|0);
10670       var $4345=$4344;
10671       var $4346=HEAP16[(($4345)>>1)];
10672       var $4347=(($4346)&65535);
10673       var $4348=(($4342+($4347<<2))|0);
10674       var $4349=$4348;
10675       var $4350=$4349;
10676       var $4351=HEAPF32[(($4350)>>2)];
10677       var $4352=$2;
10678       var $4353=(($4352+64)|0);
10679       var $4354=HEAP32[(($4353)>>2)];
10680       var $4355=$st;
10681       var $4356=(($4355+4)|0);
10682       var $4357=$4356;
10683       var $4358=HEAP16[(($4357)>>1)];
10684       var $4359=(($4358)&65535);
10685       var $4360=(($4354+($4359<<2))|0);
10686       var $4361=$4360;
10687       var $4362=$4361;
10688       var $4363=HEAPF32[(($4362)>>2)];
10689       var $4364=$4351 <= $4363;
10690       var $4365=(($4364)&1);
10691       var $4366=(($4365)|0);
10692       var $4367=$2;
10693       var $4368=(($4367+64)|0);
10694       var $4369=HEAP32[(($4368)>>2)];
10695       var $4370=$st;
10696       var $4371=(($4370+6)|0);
10697       var $4372=$4371;
10698       var $4373=HEAP16[(($4372)>>1)];
10699       var $4374=(($4373)&65535);
10700       var $4375=(($4369+($4374<<2))|0);
10701       var $4376=$4375;
10702       var $4377=$4376;
10703       HEAPF32[(($4377)>>2)]=$4366;
10704       __label__ = 245; break;
10705     case 160:
10706       var $4379=$2;
10707       var $4380=(($4379+64)|0);
10708       var $4381=HEAP32[(($4380)>>2)];
10709       var $4382=$st;
10710       var $4383=(($4382+2)|0);
10711       var $4384=$4383;
10712       var $4385=HEAP16[(($4384)>>1)];
10713       var $4386=(($4385)&65535);
10714       var $4387=(($4381+($4386<<2))|0);
10715       var $4388=$4387;
10716       var $4389=$4388;
10717       var $4390=HEAPF32[(($4389)>>2)];
10718       var $4391=$2;
10719       var $4392=(($4391+64)|0);
10720       var $4393=HEAP32[(($4392)>>2)];
10721       var $4394=$st;
10722       var $4395=(($4394+4)|0);
10723       var $4396=$4395;
10724       var $4397=HEAP16[(($4396)>>1)];
10725       var $4398=(($4397)&65535);
10726       var $4399=(($4393+($4398<<2))|0);
10727       var $4400=$4399;
10728       var $4401=$4400;
10729       var $4402=HEAPF32[(($4401)>>2)];
10730       var $4403=$4390 >= $4402;
10731       var $4404=(($4403)&1);
10732       var $4405=(($4404)|0);
10733       var $4406=$2;
10734       var $4407=(($4406+64)|0);
10735       var $4408=HEAP32[(($4407)>>2)];
10736       var $4409=$st;
10737       var $4410=(($4409+6)|0);
10738       var $4411=$4410;
10739       var $4412=HEAP16[(($4411)>>1)];
10740       var $4413=(($4412)&65535);
10741       var $4414=(($4408+($4413<<2))|0);
10742       var $4415=$4414;
10743       var $4416=$4415;
10744       HEAPF32[(($4416)>>2)]=$4405;
10745       __label__ = 245; break;
10746     case 161:
10747       var $4418=$2;
10748       var $4419=(($4418+64)|0);
10749       var $4420=HEAP32[(($4419)>>2)];
10750       var $4421=$st;
10751       var $4422=(($4421+2)|0);
10752       var $4423=$4422;
10753       var $4424=HEAP16[(($4423)>>1)];
10754       var $4425=(($4424)&65535);
10755       var $4426=(($4420+($4425<<2))|0);
10756       var $4427=$4426;
10757       var $4428=$4427;
10758       var $4429=HEAPF32[(($4428)>>2)];
10759       var $4430=$2;
10760       var $4431=(($4430+64)|0);
10761       var $4432=HEAP32[(($4431)>>2)];
10762       var $4433=$st;
10763       var $4434=(($4433+4)|0);
10764       var $4435=$4434;
10765       var $4436=HEAP16[(($4435)>>1)];
10766       var $4437=(($4436)&65535);
10767       var $4438=(($4432+($4437<<2))|0);
10768       var $4439=$4438;
10769       var $4440=$4439;
10770       var $4441=HEAPF32[(($4440)>>2)];
10771       var $4442=$4429 < $4441;
10772       var $4443=(($4442)&1);
10773       var $4444=(($4443)|0);
10774       var $4445=$2;
10775       var $4446=(($4445+64)|0);
10776       var $4447=HEAP32[(($4446)>>2)];
10777       var $4448=$st;
10778       var $4449=(($4448+6)|0);
10779       var $4450=$4449;
10780       var $4451=HEAP16[(($4450)>>1)];
10781       var $4452=(($4451)&65535);
10782       var $4453=(($4447+($4452<<2))|0);
10783       var $4454=$4453;
10784       var $4455=$4454;
10785       HEAPF32[(($4455)>>2)]=$4444;
10786       __label__ = 245; break;
10787     case 162:
10788       var $4457=$2;
10789       var $4458=(($4457+64)|0);
10790       var $4459=HEAP32[(($4458)>>2)];
10791       var $4460=$st;
10792       var $4461=(($4460+2)|0);
10793       var $4462=$4461;
10794       var $4463=HEAP16[(($4462)>>1)];
10795       var $4464=(($4463)&65535);
10796       var $4465=(($4459+($4464<<2))|0);
10797       var $4466=$4465;
10798       var $4467=$4466;
10799       var $4468=HEAPF32[(($4467)>>2)];
10800       var $4469=$2;
10801       var $4470=(($4469+64)|0);
10802       var $4471=HEAP32[(($4470)>>2)];
10803       var $4472=$st;
10804       var $4473=(($4472+4)|0);
10805       var $4474=$4473;
10806       var $4475=HEAP16[(($4474)>>1)];
10807       var $4476=(($4475)&65535);
10808       var $4477=(($4471+($4476<<2))|0);
10809       var $4478=$4477;
10810       var $4479=$4478;
10811       var $4480=HEAPF32[(($4479)>>2)];
10812       var $4481=$4468 > $4480;
10813       var $4482=(($4481)&1);
10814       var $4483=(($4482)|0);
10815       var $4484=$2;
10816       var $4485=(($4484+64)|0);
10817       var $4486=HEAP32[(($4485)>>2)];
10818       var $4487=$st;
10819       var $4488=(($4487+6)|0);
10820       var $4489=$4488;
10821       var $4490=HEAP16[(($4489)>>1)];
10822       var $4491=(($4490)&65535);
10823       var $4492=(($4486+($4491<<2))|0);
10824       var $4493=$4492;
10825       var $4494=$4493;
10826       HEAPF32[(($4494)>>2)]=$4483;
10827       __label__ = 245; break;
10828     case 163:
10829       var $4496=$2;
10830       var $4497=(($4496+64)|0);
10831       var $4498=HEAP32[(($4497)>>2)];
10832       var $4499=$st;
10833       var $4500=(($4499+2)|0);
10834       var $4501=$4500;
10835       var $4502=HEAP16[(($4501)>>1)];
10836       var $4503=(($4502)&65535);
10837       var $4504=(($4498+($4503<<2))|0);
10838       var $4505=$4504;
10839       var $4506=$4505;
10840       var $4507=HEAP32[(($4506)>>2)];
10841       var $4508=(($4507)|0) < 0;
10842       if ($4508) { __label__ = 165; break; } else { __label__ = 164; break; }
10843     case 164:
10844       var $4510=$2;
10845       var $4511=(($4510+64)|0);
10846       var $4512=HEAP32[(($4511)>>2)];
10847       var $4513=$st;
10848       var $4514=(($4513+2)|0);
10849       var $4515=$4514;
10850       var $4516=HEAP16[(($4515)>>1)];
10851       var $4517=(($4516)&65535);
10852       var $4518=(($4512+($4517<<2))|0);
10853       var $4519=$4518;
10854       var $4520=$4519;
10855       var $4521=HEAP32[(($4520)>>2)];
10856       var $4522=$2;
10857       var $4523=(($4522+140)|0);
10858       var $4524=HEAP32[(($4523)>>2)];
10859       var $4525=(($4521)|0) >= (($4524)|0);
10860       if ($4525) { __label__ = 165; break; } else { __label__ = 166; break; }
10861     case 165:
10862       var $4527=$2;
10863       var $4528=$2;
10864       var $4529=(($4528)|0);
10865       var $4530=HEAP32[(($4529)>>2)];
10866       _qcvmerror($4527, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4530,tempInt));
10867       __label__ = 488; break;
10868     case 166:
10869       var $4532=$2;
10870       var $4533=(($4532+64)|0);
10871       var $4534=HEAP32[(($4533)>>2)];
10872       var $4535=$st;
10873       var $4536=(($4535+4)|0);
10874       var $4537=$4536;
10875       var $4538=HEAP16[(($4537)>>1)];
10876       var $4539=(($4538)&65535);
10877       var $4540=(($4534+($4539<<2))|0);
10878       var $4541=$4540;
10879       var $4542=$4541;
10880       var $4543=HEAP32[(($4542)>>2)];
10881       var $4544=$2;
10882       var $4545=(($4544+144)|0);
10883       var $4546=HEAP32[(($4545)>>2)];
10884       var $4547=(($4543)>>>0) >= (($4546)>>>0);
10885       if ($4547) { __label__ = 167; break; } else { __label__ = 168; break; }
10886     case 167:
10887       var $4549=$2;
10888       var $4550=$2;
10889       var $4551=(($4550)|0);
10890       var $4552=HEAP32[(($4551)>>2)];
10891       var $4553=$2;
10892       var $4554=(($4553+64)|0);
10893       var $4555=HEAP32[(($4554)>>2)];
10894       var $4556=$st;
10895       var $4557=(($4556+4)|0);
10896       var $4558=$4557;
10897       var $4559=HEAP16[(($4558)>>1)];
10898       var $4560=(($4559)&65535);
10899       var $4561=(($4555+($4560<<2))|0);
10900       var $4562=$4561;
10901       var $4563=$4562;
10902       var $4564=HEAP32[(($4563)>>2)];
10903       _qcvmerror($4549, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4552,HEAP32[(((tempInt)+(4))>>2)]=$4564,tempInt));
10904       __label__ = 488; break;
10905     case 168:
10906       var $4566=$2;
10907       var $4567=$2;
10908       var $4568=(($4567+64)|0);
10909       var $4569=HEAP32[(($4568)>>2)];
10910       var $4570=$st;
10911       var $4571=(($4570+2)|0);
10912       var $4572=$4571;
10913       var $4573=HEAP16[(($4572)>>1)];
10914       var $4574=(($4573)&65535);
10915       var $4575=(($4569+($4574<<2))|0);
10916       var $4576=$4575;
10917       var $4577=$4576;
10918       var $4578=HEAP32[(($4577)>>2)];
10919       var $4579=_prog_getedict($4566, $4578);
10920       $ed2=$4579;
10921       var $4580=$ed2;
10922       var $4581=$4580;
10923       var $4582=$2;
10924       var $4583=(($4582+64)|0);
10925       var $4584=HEAP32[(($4583)>>2)];
10926       var $4585=$st;
10927       var $4586=(($4585+4)|0);
10928       var $4587=$4586;
10929       var $4588=HEAP16[(($4587)>>1)];
10930       var $4589=(($4588)&65535);
10931       var $4590=(($4584+($4589<<2))|0);
10932       var $4591=$4590;
10933       var $4592=$4591;
10934       var $4593=HEAP32[(($4592)>>2)];
10935       var $4594=(($4581+($4593<<2))|0);
10936       var $4595=$4594;
10937       var $4596=$4595;
10938       var $4597=HEAP32[(($4596)>>2)];
10939       var $4598=$2;
10940       var $4599=(($4598+64)|0);
10941       var $4600=HEAP32[(($4599)>>2)];
10942       var $4601=$st;
10943       var $4602=(($4601+6)|0);
10944       var $4603=$4602;
10945       var $4604=HEAP16[(($4603)>>1)];
10946       var $4605=(($4604)&65535);
10947       var $4606=(($4600+($4605<<2))|0);
10948       var $4607=$4606;
10949       var $4608=$4607;
10950       HEAP32[(($4608)>>2)]=$4597;
10951       __label__ = 245; break;
10952     case 169:
10953       var $4610=$2;
10954       var $4611=(($4610+64)|0);
10955       var $4612=HEAP32[(($4611)>>2)];
10956       var $4613=$st;
10957       var $4614=(($4613+2)|0);
10958       var $4615=$4614;
10959       var $4616=HEAP16[(($4615)>>1)];
10960       var $4617=(($4616)&65535);
10961       var $4618=(($4612+($4617<<2))|0);
10962       var $4619=$4618;
10963       var $4620=$4619;
10964       var $4621=HEAP32[(($4620)>>2)];
10965       var $4622=(($4621)|0) < 0;
10966       if ($4622) { __label__ = 171; break; } else { __label__ = 170; break; }
10967     case 170:
10968       var $4624=$2;
10969       var $4625=(($4624+64)|0);
10970       var $4626=HEAP32[(($4625)>>2)];
10971       var $4627=$st;
10972       var $4628=(($4627+2)|0);
10973       var $4629=$4628;
10974       var $4630=HEAP16[(($4629)>>1)];
10975       var $4631=(($4630)&65535);
10976       var $4632=(($4626+($4631<<2))|0);
10977       var $4633=$4632;
10978       var $4634=$4633;
10979       var $4635=HEAP32[(($4634)>>2)];
10980       var $4636=$2;
10981       var $4637=(($4636+140)|0);
10982       var $4638=HEAP32[(($4637)>>2)];
10983       var $4639=(($4635)|0) >= (($4638)|0);
10984       if ($4639) { __label__ = 171; break; } else { __label__ = 172; break; }
10985     case 171:
10986       var $4641=$2;
10987       var $4642=$2;
10988       var $4643=(($4642)|0);
10989       var $4644=HEAP32[(($4643)>>2)];
10990       _qcvmerror($4641, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4644,tempInt));
10991       __label__ = 488; break;
10992     case 172:
10993       var $4646=$2;
10994       var $4647=(($4646+64)|0);
10995       var $4648=HEAP32[(($4647)>>2)];
10996       var $4649=$st;
10997       var $4650=(($4649+4)|0);
10998       var $4651=$4650;
10999       var $4652=HEAP16[(($4651)>>1)];
11000       var $4653=(($4652)&65535);
11001       var $4654=(($4648+($4653<<2))|0);
11002       var $4655=$4654;
11003       var $4656=$4655;
11004       var $4657=HEAP32[(($4656)>>2)];
11005       var $4658=(($4657)|0) < 0;
11006       if ($4658) { __label__ = 174; break; } else { __label__ = 173; break; }
11007     case 173:
11008       var $4660=$2;
11009       var $4661=(($4660+64)|0);
11010       var $4662=HEAP32[(($4661)>>2)];
11011       var $4663=$st;
11012       var $4664=(($4663+4)|0);
11013       var $4665=$4664;
11014       var $4666=HEAP16[(($4665)>>1)];
11015       var $4667=(($4666)&65535);
11016       var $4668=(($4662+($4667<<2))|0);
11017       var $4669=$4668;
11018       var $4670=$4669;
11019       var $4671=HEAP32[(($4670)>>2)];
11020       var $4672=((($4671)+(3))|0);
11021       var $4673=$2;
11022       var $4674=(($4673+144)|0);
11023       var $4675=HEAP32[(($4674)>>2)];
11024       var $4676=(($4672)>>>0) > (($4675)>>>0);
11025       if ($4676) { __label__ = 174; break; } else { __label__ = 175; break; }
11026     case 174:
11027       var $4678=$2;
11028       var $4679=$2;
11029       var $4680=(($4679)|0);
11030       var $4681=HEAP32[(($4680)>>2)];
11031       var $4682=$2;
11032       var $4683=(($4682+64)|0);
11033       var $4684=HEAP32[(($4683)>>2)];
11034       var $4685=$st;
11035       var $4686=(($4685+4)|0);
11036       var $4687=$4686;
11037       var $4688=HEAP16[(($4687)>>1)];
11038       var $4689=(($4688)&65535);
11039       var $4690=(($4684+($4689<<2))|0);
11040       var $4691=$4690;
11041       var $4692=$4691;
11042       var $4693=HEAP32[(($4692)>>2)];
11043       var $4694=((($4693)+(2))|0);
11044       _qcvmerror($4678, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4681,HEAP32[(((tempInt)+(4))>>2)]=$4694,tempInt));
11045       __label__ = 488; break;
11046     case 175:
11047       var $4696=$2;
11048       var $4697=$2;
11049       var $4698=(($4697+64)|0);
11050       var $4699=HEAP32[(($4698)>>2)];
11051       var $4700=$st;
11052       var $4701=(($4700+2)|0);
11053       var $4702=$4701;
11054       var $4703=HEAP16[(($4702)>>1)];
11055       var $4704=(($4703)&65535);
11056       var $4705=(($4699+($4704<<2))|0);
11057       var $4706=$4705;
11058       var $4707=$4706;
11059       var $4708=HEAP32[(($4707)>>2)];
11060       var $4709=_prog_getedict($4696, $4708);
11061       $ed2=$4709;
11062       var $4710=$ed2;
11063       var $4711=$4710;
11064       var $4712=$2;
11065       var $4713=(($4712+64)|0);
11066       var $4714=HEAP32[(($4713)>>2)];
11067       var $4715=$st;
11068       var $4716=(($4715+4)|0);
11069       var $4717=$4716;
11070       var $4718=HEAP16[(($4717)>>1)];
11071       var $4719=(($4718)&65535);
11072       var $4720=(($4714+($4719<<2))|0);
11073       var $4721=$4720;
11074       var $4722=$4721;
11075       var $4723=HEAP32[(($4722)>>2)];
11076       var $4724=(($4711+($4723<<2))|0);
11077       var $4725=$4724;
11078       var $4726=$4725;
11079       var $4727=(($4726)|0);
11080       var $4728=HEAP32[(($4727)>>2)];
11081       var $4729=$2;
11082       var $4730=(($4729+64)|0);
11083       var $4731=HEAP32[(($4730)>>2)];
11084       var $4732=$st;
11085       var $4733=(($4732+6)|0);
11086       var $4734=$4733;
11087       var $4735=HEAP16[(($4734)>>1)];
11088       var $4736=(($4735)&65535);
11089       var $4737=(($4731+($4736<<2))|0);
11090       var $4738=$4737;
11091       var $4739=$4738;
11092       var $4740=(($4739)|0);
11093       HEAP32[(($4740)>>2)]=$4728;
11094       var $4741=$ed2;
11095       var $4742=$4741;
11096       var $4743=$2;
11097       var $4744=(($4743+64)|0);
11098       var $4745=HEAP32[(($4744)>>2)];
11099       var $4746=$st;
11100       var $4747=(($4746+4)|0);
11101       var $4748=$4747;
11102       var $4749=HEAP16[(($4748)>>1)];
11103       var $4750=(($4749)&65535);
11104       var $4751=(($4745+($4750<<2))|0);
11105       var $4752=$4751;
11106       var $4753=$4752;
11107       var $4754=HEAP32[(($4753)>>2)];
11108       var $4755=(($4742+($4754<<2))|0);
11109       var $4756=$4755;
11110       var $4757=$4756;
11111       var $4758=(($4757+4)|0);
11112       var $4759=HEAP32[(($4758)>>2)];
11113       var $4760=$2;
11114       var $4761=(($4760+64)|0);
11115       var $4762=HEAP32[(($4761)>>2)];
11116       var $4763=$st;
11117       var $4764=(($4763+6)|0);
11118       var $4765=$4764;
11119       var $4766=HEAP16[(($4765)>>1)];
11120       var $4767=(($4766)&65535);
11121       var $4768=(($4762+($4767<<2))|0);
11122       var $4769=$4768;
11123       var $4770=$4769;
11124       var $4771=(($4770+4)|0);
11125       HEAP32[(($4771)>>2)]=$4759;
11126       var $4772=$ed2;
11127       var $4773=$4772;
11128       var $4774=$2;
11129       var $4775=(($4774+64)|0);
11130       var $4776=HEAP32[(($4775)>>2)];
11131       var $4777=$st;
11132       var $4778=(($4777+4)|0);
11133       var $4779=$4778;
11134       var $4780=HEAP16[(($4779)>>1)];
11135       var $4781=(($4780)&65535);
11136       var $4782=(($4776+($4781<<2))|0);
11137       var $4783=$4782;
11138       var $4784=$4783;
11139       var $4785=HEAP32[(($4784)>>2)];
11140       var $4786=(($4773+($4785<<2))|0);
11141       var $4787=$4786;
11142       var $4788=$4787;
11143       var $4789=(($4788+8)|0);
11144       var $4790=HEAP32[(($4789)>>2)];
11145       var $4791=$2;
11146       var $4792=(($4791+64)|0);
11147       var $4793=HEAP32[(($4792)>>2)];
11148       var $4794=$st;
11149       var $4795=(($4794+6)|0);
11150       var $4796=$4795;
11151       var $4797=HEAP16[(($4796)>>1)];
11152       var $4798=(($4797)&65535);
11153       var $4799=(($4793+($4798<<2))|0);
11154       var $4800=$4799;
11155       var $4801=$4800;
11156       var $4802=(($4801+8)|0);
11157       HEAP32[(($4802)>>2)]=$4790;
11158       __label__ = 245; break;
11159     case 176:
11160       var $4804=$2;
11161       var $4805=(($4804+64)|0);
11162       var $4806=HEAP32[(($4805)>>2)];
11163       var $4807=$st;
11164       var $4808=(($4807+2)|0);
11165       var $4809=$4808;
11166       var $4810=HEAP16[(($4809)>>1)];
11167       var $4811=(($4810)&65535);
11168       var $4812=(($4806+($4811<<2))|0);
11169       var $4813=$4812;
11170       var $4814=$4813;
11171       var $4815=HEAP32[(($4814)>>2)];
11172       var $4816=(($4815)|0) < 0;
11173       if ($4816) { __label__ = 178; break; } else { __label__ = 177; break; }
11174     case 177:
11175       var $4818=$2;
11176       var $4819=(($4818+64)|0);
11177       var $4820=HEAP32[(($4819)>>2)];
11178       var $4821=$st;
11179       var $4822=(($4821+2)|0);
11180       var $4823=$4822;
11181       var $4824=HEAP16[(($4823)>>1)];
11182       var $4825=(($4824)&65535);
11183       var $4826=(($4820+($4825<<2))|0);
11184       var $4827=$4826;
11185       var $4828=$4827;
11186       var $4829=HEAP32[(($4828)>>2)];
11187       var $4830=$2;
11188       var $4831=(($4830+140)|0);
11189       var $4832=HEAP32[(($4831)>>2)];
11190       var $4833=(($4829)|0) >= (($4832)|0);
11191       if ($4833) { __label__ = 178; break; } else { __label__ = 179; break; }
11192     case 178:
11193       var $4835=$2;
11194       var $4836=$2;
11195       var $4837=(($4836)|0);
11196       var $4838=HEAP32[(($4837)>>2)];
11197       var $4839=$2;
11198       var $4840=(($4839+64)|0);
11199       var $4841=HEAP32[(($4840)>>2)];
11200       var $4842=$st;
11201       var $4843=(($4842+2)|0);
11202       var $4844=$4843;
11203       var $4845=HEAP16[(($4844)>>1)];
11204       var $4846=(($4845)&65535);
11205       var $4847=(($4841+($4846<<2))|0);
11206       var $4848=$4847;
11207       var $4849=$4848;
11208       var $4850=HEAP32[(($4849)>>2)];
11209       _qcvmerror($4835, ((STRING_TABLE.__str19)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4838,HEAP32[(((tempInt)+(4))>>2)]=$4850,tempInt));
11210       __label__ = 488; break;
11211     case 179:
11212       var $4852=$2;
11213       var $4853=(($4852+64)|0);
11214       var $4854=HEAP32[(($4853)>>2)];
11215       var $4855=$st;
11216       var $4856=(($4855+4)|0);
11217       var $4857=$4856;
11218       var $4858=HEAP16[(($4857)>>1)];
11219       var $4859=(($4858)&65535);
11220       var $4860=(($4854+($4859<<2))|0);
11221       var $4861=$4860;
11222       var $4862=$4861;
11223       var $4863=HEAP32[(($4862)>>2)];
11224       var $4864=$2;
11225       var $4865=(($4864+144)|0);
11226       var $4866=HEAP32[(($4865)>>2)];
11227       var $4867=(($4863)>>>0) >= (($4866)>>>0);
11228       if ($4867) { __label__ = 180; break; } else { __label__ = 181; break; }
11229     case 180:
11230       var $4869=$2;
11231       var $4870=$2;
11232       var $4871=(($4870)|0);
11233       var $4872=HEAP32[(($4871)>>2)];
11234       var $4873=$2;
11235       var $4874=(($4873+64)|0);
11236       var $4875=HEAP32[(($4874)>>2)];
11237       var $4876=$st;
11238       var $4877=(($4876+4)|0);
11239       var $4878=$4877;
11240       var $4879=HEAP16[(($4878)>>1)];
11241       var $4880=(($4879)&65535);
11242       var $4881=(($4875+($4880<<2))|0);
11243       var $4882=$4881;
11244       var $4883=$4882;
11245       var $4884=HEAP32[(($4883)>>2)];
11246       _qcvmerror($4869, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$4872,HEAP32[(((tempInt)+(4))>>2)]=$4884,tempInt));
11247       __label__ = 488; break;
11248     case 181:
11249       var $4886=$2;
11250       var $4887=$2;
11251       var $4888=(($4887+64)|0);
11252       var $4889=HEAP32[(($4888)>>2)];
11253       var $4890=$st;
11254       var $4891=(($4890+2)|0);
11255       var $4892=$4891;
11256       var $4893=HEAP16[(($4892)>>1)];
11257       var $4894=(($4893)&65535);
11258       var $4895=(($4889+($4894<<2))|0);
11259       var $4896=$4895;
11260       var $4897=$4896;
11261       var $4898=HEAP32[(($4897)>>2)];
11262       var $4899=_prog_getedict($4886, $4898);
11263       $ed2=$4899;
11264       var $4900=$ed2;
11265       var $4901=$4900;
11266       var $4902=$2;
11267       var $4903=(($4902+76)|0);
11268       var $4904=HEAP32[(($4903)>>2)];
11269       var $4905=$4901;
11270       var $4906=$4904;
11271       var $4907=((($4905)-($4906))|0);
11272       var $4908=((((($4907)|0))/(4))&-1);
11273       var $4909=$2;
11274       var $4910=(($4909+64)|0);
11275       var $4911=HEAP32[(($4910)>>2)];
11276       var $4912=$st;
11277       var $4913=(($4912+6)|0);
11278       var $4914=$4913;
11279       var $4915=HEAP16[(($4914)>>1)];
11280       var $4916=(($4915)&65535);
11281       var $4917=(($4911+($4916<<2))|0);
11282       var $4918=$4917;
11283       var $4919=$4918;
11284       HEAP32[(($4919)>>2)]=$4908;
11285       var $4920=$2;
11286       var $4921=(($4920+64)|0);
11287       var $4922=HEAP32[(($4921)>>2)];
11288       var $4923=$st;
11289       var $4924=(($4923+4)|0);
11290       var $4925=$4924;
11291       var $4926=HEAP16[(($4925)>>1)];
11292       var $4927=(($4926)&65535);
11293       var $4928=(($4922+($4927<<2))|0);
11294       var $4929=$4928;
11295       var $4930=$4929;
11296       var $4931=HEAP32[(($4930)>>2)];
11297       var $4932=$2;
11298       var $4933=(($4932+64)|0);
11299       var $4934=HEAP32[(($4933)>>2)];
11300       var $4935=$st;
11301       var $4936=(($4935+6)|0);
11302       var $4937=$4936;
11303       var $4938=HEAP16[(($4937)>>1)];
11304       var $4939=(($4938)&65535);
11305       var $4940=(($4934+($4939<<2))|0);
11306       var $4941=$4940;
11307       var $4942=$4941;
11308       var $4943=HEAP32[(($4942)>>2)];
11309       var $4944=((($4943)+($4931))|0);
11310       HEAP32[(($4942)>>2)]=$4944;
11311       __label__ = 245; break;
11312     case 182:
11313       var $4946=$2;
11314       var $4947=(($4946+64)|0);
11315       var $4948=HEAP32[(($4947)>>2)];
11316       var $4949=$st;
11317       var $4950=(($4949+2)|0);
11318       var $4951=$4950;
11319       var $4952=HEAP16[(($4951)>>1)];
11320       var $4953=(($4952)&65535);
11321       var $4954=(($4948+($4953<<2))|0);
11322       var $4955=$4954;
11323       var $4956=$4955;
11324       var $4957=HEAP32[(($4956)>>2)];
11325       var $4958=$2;
11326       var $4959=(($4958+64)|0);
11327       var $4960=HEAP32[(($4959)>>2)];
11328       var $4961=$st;
11329       var $4962=(($4961+4)|0);
11330       var $4963=$4962;
11331       var $4964=HEAP16[(($4963)>>1)];
11332       var $4965=(($4964)&65535);
11333       var $4966=(($4960+($4965<<2))|0);
11334       var $4967=$4966;
11335       var $4968=$4967;
11336       HEAP32[(($4968)>>2)]=$4957;
11337       __label__ = 245; break;
11338     case 183:
11339       var $4970=$2;
11340       var $4971=(($4970+64)|0);
11341       var $4972=HEAP32[(($4971)>>2)];
11342       var $4973=$st;
11343       var $4974=(($4973+2)|0);
11344       var $4975=$4974;
11345       var $4976=HEAP16[(($4975)>>1)];
11346       var $4977=(($4976)&65535);
11347       var $4978=(($4972+($4977<<2))|0);
11348       var $4979=$4978;
11349       var $4980=$4979;
11350       var $4981=(($4980)|0);
11351       var $4982=HEAP32[(($4981)>>2)];
11352       var $4983=$2;
11353       var $4984=(($4983+64)|0);
11354       var $4985=HEAP32[(($4984)>>2)];
11355       var $4986=$st;
11356       var $4987=(($4986+4)|0);
11357       var $4988=$4987;
11358       var $4989=HEAP16[(($4988)>>1)];
11359       var $4990=(($4989)&65535);
11360       var $4991=(($4985+($4990<<2))|0);
11361       var $4992=$4991;
11362       var $4993=$4992;
11363       var $4994=(($4993)|0);
11364       HEAP32[(($4994)>>2)]=$4982;
11365       var $4995=$2;
11366       var $4996=(($4995+64)|0);
11367       var $4997=HEAP32[(($4996)>>2)];
11368       var $4998=$st;
11369       var $4999=(($4998+2)|0);
11370       var $5000=$4999;
11371       var $5001=HEAP16[(($5000)>>1)];
11372       var $5002=(($5001)&65535);
11373       var $5003=(($4997+($5002<<2))|0);
11374       var $5004=$5003;
11375       var $5005=$5004;
11376       var $5006=(($5005+4)|0);
11377       var $5007=HEAP32[(($5006)>>2)];
11378       var $5008=$2;
11379       var $5009=(($5008+64)|0);
11380       var $5010=HEAP32[(($5009)>>2)];
11381       var $5011=$st;
11382       var $5012=(($5011+4)|0);
11383       var $5013=$5012;
11384       var $5014=HEAP16[(($5013)>>1)];
11385       var $5015=(($5014)&65535);
11386       var $5016=(($5010+($5015<<2))|0);
11387       var $5017=$5016;
11388       var $5018=$5017;
11389       var $5019=(($5018+4)|0);
11390       HEAP32[(($5019)>>2)]=$5007;
11391       var $5020=$2;
11392       var $5021=(($5020+64)|0);
11393       var $5022=HEAP32[(($5021)>>2)];
11394       var $5023=$st;
11395       var $5024=(($5023+2)|0);
11396       var $5025=$5024;
11397       var $5026=HEAP16[(($5025)>>1)];
11398       var $5027=(($5026)&65535);
11399       var $5028=(($5022+($5027<<2))|0);
11400       var $5029=$5028;
11401       var $5030=$5029;
11402       var $5031=(($5030+8)|0);
11403       var $5032=HEAP32[(($5031)>>2)];
11404       var $5033=$2;
11405       var $5034=(($5033+64)|0);
11406       var $5035=HEAP32[(($5034)>>2)];
11407       var $5036=$st;
11408       var $5037=(($5036+4)|0);
11409       var $5038=$5037;
11410       var $5039=HEAP16[(($5038)>>1)];
11411       var $5040=(($5039)&65535);
11412       var $5041=(($5035+($5040<<2))|0);
11413       var $5042=$5041;
11414       var $5043=$5042;
11415       var $5044=(($5043+8)|0);
11416       HEAP32[(($5044)>>2)]=$5032;
11417       __label__ = 245; break;
11418     case 184:
11419       var $5046=$2;
11420       var $5047=(($5046+64)|0);
11421       var $5048=HEAP32[(($5047)>>2)];
11422       var $5049=$st;
11423       var $5050=(($5049+4)|0);
11424       var $5051=$5050;
11425       var $5052=HEAP16[(($5051)>>1)];
11426       var $5053=(($5052)&65535);
11427       var $5054=(($5048+($5053<<2))|0);
11428       var $5055=$5054;
11429       var $5056=$5055;
11430       var $5057=HEAP32[(($5056)>>2)];
11431       var $5058=(($5057)|0) < 0;
11432       if ($5058) { __label__ = 186; break; } else { __label__ = 185; break; }
11433     case 185:
11434       var $5060=$2;
11435       var $5061=(($5060+64)|0);
11436       var $5062=HEAP32[(($5061)>>2)];
11437       var $5063=$st;
11438       var $5064=(($5063+4)|0);
11439       var $5065=$5064;
11440       var $5066=HEAP16[(($5065)>>1)];
11441       var $5067=(($5066)&65535);
11442       var $5068=(($5062+($5067<<2))|0);
11443       var $5069=$5068;
11444       var $5070=$5069;
11445       var $5071=HEAP32[(($5070)>>2)];
11446       var $5072=$2;
11447       var $5073=(($5072+80)|0);
11448       var $5074=HEAP32[(($5073)>>2)];
11449       var $5075=(($5071)>>>0) >= (($5074)>>>0);
11450       if ($5075) { __label__ = 186; break; } else { __label__ = 187; break; }
11451     case 186:
11452       var $5077=$2;
11453       var $5078=$2;
11454       var $5079=(($5078)|0);
11455       var $5080=HEAP32[(($5079)>>2)];
11456       var $5081=$2;
11457       var $5082=(($5081+64)|0);
11458       var $5083=HEAP32[(($5082)>>2)];
11459       var $5084=$st;
11460       var $5085=(($5084+4)|0);
11461       var $5086=$5085;
11462       var $5087=HEAP16[(($5086)>>1)];
11463       var $5088=(($5087)&65535);
11464       var $5089=(($5083+($5088<<2))|0);
11465       var $5090=$5089;
11466       var $5091=$5090;
11467       var $5092=HEAP32[(($5091)>>2)];
11468       _qcvmerror($5077, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5080,HEAP32[(((tempInt)+(4))>>2)]=$5092,tempInt));
11469       __label__ = 488; break;
11470     case 187:
11471       var $5094=$2;
11472       var $5095=(($5094+64)|0);
11473       var $5096=HEAP32[(($5095)>>2)];
11474       var $5097=$st;
11475       var $5098=(($5097+4)|0);
11476       var $5099=$5098;
11477       var $5100=HEAP16[(($5099)>>1)];
11478       var $5101=(($5100)&65535);
11479       var $5102=(($5096+($5101<<2))|0);
11480       var $5103=$5102;
11481       var $5104=$5103;
11482       var $5105=HEAP32[(($5104)>>2)];
11483       var $5106=$2;
11484       var $5107=(($5106+144)|0);
11485       var $5108=HEAP32[(($5107)>>2)];
11486       var $5109=(($5105)>>>0) < (($5108)>>>0);
11487       if ($5109) { __label__ = 188; break; } else { __label__ = 190; break; }
11488     case 188:
11489       var $5111=$2;
11490       var $5112=(($5111+148)|0);
11491       var $5113=HEAP8[($5112)];
11492       var $5114=(($5113) & 1);
11493       if ($5114) { __label__ = 190; break; } else { __label__ = 189; break; }
11494     case 189:
11495       var $5116=$2;
11496       var $5117=$2;
11497       var $5118=(($5117)|0);
11498       var $5119=HEAP32[(($5118)>>2)];
11499       var $5120=$2;
11500       var $5121=$2;
11501       var $5122=$2;
11502       var $5123=(($5122+64)|0);
11503       var $5124=HEAP32[(($5123)>>2)];
11504       var $5125=$st;
11505       var $5126=(($5125+4)|0);
11506       var $5127=$5126;
11507       var $5128=HEAP16[(($5127)>>1)];
11508       var $5129=(($5128)&65535);
11509       var $5130=(($5124+($5129<<2))|0);
11510       var $5131=$5130;
11511       var $5132=$5131;
11512       var $5133=HEAP32[(($5132)>>2)];
11513       var $5134=_prog_entfield($5121, $5133);
11514       var $5135=(($5134+4)|0);
11515       var $5136=HEAP32[(($5135)>>2)];
11516       var $5137=_prog_getstring($5120, $5136);
11517       var $5138=$2;
11518       var $5139=(($5138+64)|0);
11519       var $5140=HEAP32[(($5139)>>2)];
11520       var $5141=$st;
11521       var $5142=(($5141+4)|0);
11522       var $5143=$5142;
11523       var $5144=HEAP16[(($5143)>>1)];
11524       var $5145=(($5144)&65535);
11525       var $5146=(($5140+($5145<<2))|0);
11526       var $5147=$5146;
11527       var $5148=$5147;
11528       var $5149=HEAP32[(($5148)>>2)];
11529       _qcvmerror($5116, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5119,HEAP32[(((tempInt)+(4))>>2)]=$5137,HEAP32[(((tempInt)+(8))>>2)]=$5149,tempInt));
11530       __label__ = 190; break;
11531     case 190:
11532       var $5151=$2;
11533       var $5152=(($5151+76)|0);
11534       var $5153=HEAP32[(($5152)>>2)];
11535       var $5154=$2;
11536       var $5155=(($5154+64)|0);
11537       var $5156=HEAP32[(($5155)>>2)];
11538       var $5157=$st;
11539       var $5158=(($5157+4)|0);
11540       var $5159=$5158;
11541       var $5160=HEAP16[(($5159)>>1)];
11542       var $5161=(($5160)&65535);
11543       var $5162=(($5156+($5161<<2))|0);
11544       var $5163=$5162;
11545       var $5164=$5163;
11546       var $5165=HEAP32[(($5164)>>2)];
11547       var $5166=(($5153+($5165<<2))|0);
11548       var $5167=$5166;
11549       $ptr3=$5167;
11550       var $5168=$2;
11551       var $5169=(($5168+64)|0);
11552       var $5170=HEAP32[(($5169)>>2)];
11553       var $5171=$st;
11554       var $5172=(($5171+2)|0);
11555       var $5173=$5172;
11556       var $5174=HEAP16[(($5173)>>1)];
11557       var $5175=(($5174)&65535);
11558       var $5176=(($5170+($5175<<2))|0);
11559       var $5177=$5176;
11560       var $5178=$5177;
11561       var $5179=HEAP32[(($5178)>>2)];
11562       var $5180=$ptr3;
11563       var $5181=$5180;
11564       HEAP32[(($5181)>>2)]=$5179;
11565       __label__ = 245; break;
11566     case 191:
11567       var $5183=$2;
11568       var $5184=(($5183+64)|0);
11569       var $5185=HEAP32[(($5184)>>2)];
11570       var $5186=$st;
11571       var $5187=(($5186+4)|0);
11572       var $5188=$5187;
11573       var $5189=HEAP16[(($5188)>>1)];
11574       var $5190=(($5189)&65535);
11575       var $5191=(($5185+($5190<<2))|0);
11576       var $5192=$5191;
11577       var $5193=$5192;
11578       var $5194=HEAP32[(($5193)>>2)];
11579       var $5195=(($5194)|0) < 0;
11580       if ($5195) { __label__ = 193; break; } else { __label__ = 192; break; }
11581     case 192:
11582       var $5197=$2;
11583       var $5198=(($5197+64)|0);
11584       var $5199=HEAP32[(($5198)>>2)];
11585       var $5200=$st;
11586       var $5201=(($5200+4)|0);
11587       var $5202=$5201;
11588       var $5203=HEAP16[(($5202)>>1)];
11589       var $5204=(($5203)&65535);
11590       var $5205=(($5199+($5204<<2))|0);
11591       var $5206=$5205;
11592       var $5207=$5206;
11593       var $5208=HEAP32[(($5207)>>2)];
11594       var $5209=((($5208)+(2))|0);
11595       var $5210=$2;
11596       var $5211=(($5210+80)|0);
11597       var $5212=HEAP32[(($5211)>>2)];
11598       var $5213=(($5209)>>>0) >= (($5212)>>>0);
11599       if ($5213) { __label__ = 193; break; } else { __label__ = 194; break; }
11600     case 193:
11601       var $5215=$2;
11602       var $5216=$2;
11603       var $5217=(($5216)|0);
11604       var $5218=HEAP32[(($5217)>>2)];
11605       var $5219=$2;
11606       var $5220=(($5219+64)|0);
11607       var $5221=HEAP32[(($5220)>>2)];
11608       var $5222=$st;
11609       var $5223=(($5222+4)|0);
11610       var $5224=$5223;
11611       var $5225=HEAP16[(($5224)>>1)];
11612       var $5226=(($5225)&65535);
11613       var $5227=(($5221+($5226<<2))|0);
11614       var $5228=$5227;
11615       var $5229=$5228;
11616       var $5230=HEAP32[(($5229)>>2)];
11617       _qcvmerror($5215, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5218,HEAP32[(((tempInt)+(4))>>2)]=$5230,tempInt));
11618       __label__ = 488; break;
11619     case 194:
11620       var $5232=$2;
11621       var $5233=(($5232+64)|0);
11622       var $5234=HEAP32[(($5233)>>2)];
11623       var $5235=$st;
11624       var $5236=(($5235+4)|0);
11625       var $5237=$5236;
11626       var $5238=HEAP16[(($5237)>>1)];
11627       var $5239=(($5238)&65535);
11628       var $5240=(($5234+($5239<<2))|0);
11629       var $5241=$5240;
11630       var $5242=$5241;
11631       var $5243=HEAP32[(($5242)>>2)];
11632       var $5244=$2;
11633       var $5245=(($5244+144)|0);
11634       var $5246=HEAP32[(($5245)>>2)];
11635       var $5247=(($5243)>>>0) < (($5246)>>>0);
11636       if ($5247) { __label__ = 195; break; } else { __label__ = 197; break; }
11637     case 195:
11638       var $5249=$2;
11639       var $5250=(($5249+148)|0);
11640       var $5251=HEAP8[($5250)];
11641       var $5252=(($5251) & 1);
11642       if ($5252) { __label__ = 197; break; } else { __label__ = 196; break; }
11643     case 196:
11644       var $5254=$2;
11645       var $5255=$2;
11646       var $5256=(($5255)|0);
11647       var $5257=HEAP32[(($5256)>>2)];
11648       var $5258=$2;
11649       var $5259=$2;
11650       var $5260=$2;
11651       var $5261=(($5260+64)|0);
11652       var $5262=HEAP32[(($5261)>>2)];
11653       var $5263=$st;
11654       var $5264=(($5263+4)|0);
11655       var $5265=$5264;
11656       var $5266=HEAP16[(($5265)>>1)];
11657       var $5267=(($5266)&65535);
11658       var $5268=(($5262+($5267<<2))|0);
11659       var $5269=$5268;
11660       var $5270=$5269;
11661       var $5271=HEAP32[(($5270)>>2)];
11662       var $5272=_prog_entfield($5259, $5271);
11663       var $5273=(($5272+4)|0);
11664       var $5274=HEAP32[(($5273)>>2)];
11665       var $5275=_prog_getstring($5258, $5274);
11666       var $5276=$2;
11667       var $5277=(($5276+64)|0);
11668       var $5278=HEAP32[(($5277)>>2)];
11669       var $5279=$st;
11670       var $5280=(($5279+4)|0);
11671       var $5281=$5280;
11672       var $5282=HEAP16[(($5281)>>1)];
11673       var $5283=(($5282)&65535);
11674       var $5284=(($5278+($5283<<2))|0);
11675       var $5285=$5284;
11676       var $5286=$5285;
11677       var $5287=HEAP32[(($5286)>>2)];
11678       _qcvmerror($5254, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5257,HEAP32[(((tempInt)+(4))>>2)]=$5275,HEAP32[(((tempInt)+(8))>>2)]=$5287,tempInt));
11679       __label__ = 197; break;
11680     case 197:
11681       var $5289=$2;
11682       var $5290=(($5289+76)|0);
11683       var $5291=HEAP32[(($5290)>>2)];
11684       var $5292=$2;
11685       var $5293=(($5292+64)|0);
11686       var $5294=HEAP32[(($5293)>>2)];
11687       var $5295=$st;
11688       var $5296=(($5295+4)|0);
11689       var $5297=$5296;
11690       var $5298=HEAP16[(($5297)>>1)];
11691       var $5299=(($5298)&65535);
11692       var $5300=(($5294+($5299<<2))|0);
11693       var $5301=$5300;
11694       var $5302=$5301;
11695       var $5303=HEAP32[(($5302)>>2)];
11696       var $5304=(($5291+($5303<<2))|0);
11697       var $5305=$5304;
11698       $ptr3=$5305;
11699       var $5306=$2;
11700       var $5307=(($5306+64)|0);
11701       var $5308=HEAP32[(($5307)>>2)];
11702       var $5309=$st;
11703       var $5310=(($5309+2)|0);
11704       var $5311=$5310;
11705       var $5312=HEAP16[(($5311)>>1)];
11706       var $5313=(($5312)&65535);
11707       var $5314=(($5308+($5313<<2))|0);
11708       var $5315=$5314;
11709       var $5316=$5315;
11710       var $5317=(($5316)|0);
11711       var $5318=HEAP32[(($5317)>>2)];
11712       var $5319=$ptr3;
11713       var $5320=$5319;
11714       var $5321=(($5320)|0);
11715       HEAP32[(($5321)>>2)]=$5318;
11716       var $5322=$2;
11717       var $5323=(($5322+64)|0);
11718       var $5324=HEAP32[(($5323)>>2)];
11719       var $5325=$st;
11720       var $5326=(($5325+2)|0);
11721       var $5327=$5326;
11722       var $5328=HEAP16[(($5327)>>1)];
11723       var $5329=(($5328)&65535);
11724       var $5330=(($5324+($5329<<2))|0);
11725       var $5331=$5330;
11726       var $5332=$5331;
11727       var $5333=(($5332+4)|0);
11728       var $5334=HEAP32[(($5333)>>2)];
11729       var $5335=$ptr3;
11730       var $5336=$5335;
11731       var $5337=(($5336+4)|0);
11732       HEAP32[(($5337)>>2)]=$5334;
11733       var $5338=$2;
11734       var $5339=(($5338+64)|0);
11735       var $5340=HEAP32[(($5339)>>2)];
11736       var $5341=$st;
11737       var $5342=(($5341+2)|0);
11738       var $5343=$5342;
11739       var $5344=HEAP16[(($5343)>>1)];
11740       var $5345=(($5344)&65535);
11741       var $5346=(($5340+($5345<<2))|0);
11742       var $5347=$5346;
11743       var $5348=$5347;
11744       var $5349=(($5348+8)|0);
11745       var $5350=HEAP32[(($5349)>>2)];
11746       var $5351=$ptr3;
11747       var $5352=$5351;
11748       var $5353=(($5352+8)|0);
11749       HEAP32[(($5353)>>2)]=$5350;
11750       __label__ = 245; break;
11751     case 198:
11752       var $5355=$2;
11753       var $5356=(($5355+64)|0);
11754       var $5357=HEAP32[(($5356)>>2)];
11755       var $5358=$st;
11756       var $5359=(($5358+2)|0);
11757       var $5360=$5359;
11758       var $5361=HEAP16[(($5360)>>1)];
11759       var $5362=(($5361)&65535);
11760       var $5363=(($5357+($5362<<2))|0);
11761       var $5364=$5363;
11762       var $5365=$5364;
11763       var $5366=HEAP32[(($5365)>>2)];
11764       var $5367=$5366 & 2147483647;
11765       var $5368=(($5367)|0)!=0;
11766       var $5369=$5368 ^ 1;
11767       var $5370=(($5369)&1);
11768       var $5371=(($5370)|0);
11769       var $5372=$2;
11770       var $5373=(($5372+64)|0);
11771       var $5374=HEAP32[(($5373)>>2)];
11772       var $5375=$st;
11773       var $5376=(($5375+6)|0);
11774       var $5377=$5376;
11775       var $5378=HEAP16[(($5377)>>1)];
11776       var $5379=(($5378)&65535);
11777       var $5380=(($5374+($5379<<2))|0);
11778       var $5381=$5380;
11779       var $5382=$5381;
11780       HEAPF32[(($5382)>>2)]=$5371;
11781       __label__ = 245; break;
11782     case 199:
11783       var $5384=$2;
11784       var $5385=(($5384+64)|0);
11785       var $5386=HEAP32[(($5385)>>2)];
11786       var $5387=$st;
11787       var $5388=(($5387+2)|0);
11788       var $5389=$5388;
11789       var $5390=HEAP16[(($5389)>>1)];
11790       var $5391=(($5390)&65535);
11791       var $5392=(($5386+($5391<<2))|0);
11792       var $5393=$5392;
11793       var $5394=$5393;
11794       var $5395=(($5394)|0);
11795       var $5396=HEAPF32[(($5395)>>2)];
11796       var $5397=$5396 != 0;
11797       if ($5397) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 200; break; }
11798     case 200:
11799       var $5399=$2;
11800       var $5400=(($5399+64)|0);
11801       var $5401=HEAP32[(($5400)>>2)];
11802       var $5402=$st;
11803       var $5403=(($5402+2)|0);
11804       var $5404=$5403;
11805       var $5405=HEAP16[(($5404)>>1)];
11806       var $5406=(($5405)&65535);
11807       var $5407=(($5401+($5406<<2))|0);
11808       var $5408=$5407;
11809       var $5409=$5408;
11810       var $5410=(($5409+4)|0);
11811       var $5411=HEAPF32[(($5410)>>2)];
11812       var $5412=$5411 != 0;
11813       if ($5412) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 201; break; }
11814     case 201:
11815       var $5414=$2;
11816       var $5415=(($5414+64)|0);
11817       var $5416=HEAP32[(($5415)>>2)];
11818       var $5417=$st;
11819       var $5418=(($5417+2)|0);
11820       var $5419=$5418;
11821       var $5420=HEAP16[(($5419)>>1)];
11822       var $5421=(($5420)&65535);
11823       var $5422=(($5416+($5421<<2))|0);
11824       var $5423=$5422;
11825       var $5424=$5423;
11826       var $5425=(($5424+8)|0);
11827       var $5426=HEAPF32[(($5425)>>2)];
11828       var $5427=$5426 != 0;
11829       var $5428=$5427 ^ 1;
11830       var $5430 = $5428;__label__ = 202; break;
11831     case 202:
11832       var $5430;
11833       var $5431=(($5430)&1);
11834       var $5432=(($5431)|0);
11835       var $5433=$2;
11836       var $5434=(($5433+64)|0);
11837       var $5435=HEAP32[(($5434)>>2)];
11838       var $5436=$st;
11839       var $5437=(($5436+6)|0);
11840       var $5438=$5437;
11841       var $5439=HEAP16[(($5438)>>1)];
11842       var $5440=(($5439)&65535);
11843       var $5441=(($5435+($5440<<2))|0);
11844       var $5442=$5441;
11845       var $5443=$5442;
11846       HEAPF32[(($5443)>>2)]=$5432;
11847       __label__ = 245; break;
11848     case 203:
11849       var $5445=$2;
11850       var $5446=(($5445+64)|0);
11851       var $5447=HEAP32[(($5446)>>2)];
11852       var $5448=$st;
11853       var $5449=(($5448+2)|0);
11854       var $5450=$5449;
11855       var $5451=HEAP16[(($5450)>>1)];
11856       var $5452=(($5451)&65535);
11857       var $5453=(($5447+($5452<<2))|0);
11858       var $5454=$5453;
11859       var $5455=$5454;
11860       var $5456=HEAP32[(($5455)>>2)];
11861       var $5457=(($5456)|0)!=0;
11862       if ($5457) { __label__ = 204; break; } else { var $5477 = 1;__label__ = 205; break; }
11863     case 204:
11864       var $5459=$2;
11865       var $5460=$2;
11866       var $5461=(($5460+64)|0);
11867       var $5462=HEAP32[(($5461)>>2)];
11868       var $5463=$st;
11869       var $5464=(($5463+2)|0);
11870       var $5465=$5464;
11871       var $5466=HEAP16[(($5465)>>1)];
11872       var $5467=(($5466)&65535);
11873       var $5468=(($5462+($5467<<2))|0);
11874       var $5469=$5468;
11875       var $5470=$5469;
11876       var $5471=HEAP32[(($5470)>>2)];
11877       var $5472=_prog_getstring($5459, $5471);
11878       var $5473=HEAP8[($5472)];
11879       var $5474=(($5473 << 24) >> 24)!=0;
11880       var $5475=$5474 ^ 1;
11881       var $5477 = $5475;__label__ = 205; break;
11882     case 205:
11883       var $5477;
11884       var $5478=(($5477)&1);
11885       var $5479=(($5478)|0);
11886       var $5480=$2;
11887       var $5481=(($5480+64)|0);
11888       var $5482=HEAP32[(($5481)>>2)];
11889       var $5483=$st;
11890       var $5484=(($5483+6)|0);
11891       var $5485=$5484;
11892       var $5486=HEAP16[(($5485)>>1)];
11893       var $5487=(($5486)&65535);
11894       var $5488=(($5482+($5487<<2))|0);
11895       var $5489=$5488;
11896       var $5490=$5489;
11897       HEAPF32[(($5490)>>2)]=$5479;
11898       __label__ = 245; break;
11899     case 206:
11900       var $5492=$2;
11901       var $5493=(($5492+64)|0);
11902       var $5494=HEAP32[(($5493)>>2)];
11903       var $5495=$st;
11904       var $5496=(($5495+2)|0);
11905       var $5497=$5496;
11906       var $5498=HEAP16[(($5497)>>1)];
11907       var $5499=(($5498)&65535);
11908       var $5500=(($5494+($5499<<2))|0);
11909       var $5501=$5500;
11910       var $5502=$5501;
11911       var $5503=HEAP32[(($5502)>>2)];
11912       var $5504=(($5503)|0)==0;
11913       var $5505=(($5504)&1);
11914       var $5506=(($5505)|0);
11915       var $5507=$2;
11916       var $5508=(($5507+64)|0);
11917       var $5509=HEAP32[(($5508)>>2)];
11918       var $5510=$st;
11919       var $5511=(($5510+6)|0);
11920       var $5512=$5511;
11921       var $5513=HEAP16[(($5512)>>1)];
11922       var $5514=(($5513)&65535);
11923       var $5515=(($5509+($5514<<2))|0);
11924       var $5516=$5515;
11925       var $5517=$5516;
11926       HEAPF32[(($5517)>>2)]=$5506;
11927       __label__ = 245; break;
11928     case 207:
11929       var $5519=$2;
11930       var $5520=(($5519+64)|0);
11931       var $5521=HEAP32[(($5520)>>2)];
11932       var $5522=$st;
11933       var $5523=(($5522+2)|0);
11934       var $5524=$5523;
11935       var $5525=HEAP16[(($5524)>>1)];
11936       var $5526=(($5525)&65535);
11937       var $5527=(($5521+($5526<<2))|0);
11938       var $5528=$5527;
11939       var $5529=$5528;
11940       var $5530=HEAP32[(($5529)>>2)];
11941       var $5531=(($5530)|0)!=0;
11942       var $5532=$5531 ^ 1;
11943       var $5533=(($5532)&1);
11944       var $5534=(($5533)|0);
11945       var $5535=$2;
11946       var $5536=(($5535+64)|0);
11947       var $5537=HEAP32[(($5536)>>2)];
11948       var $5538=$st;
11949       var $5539=(($5538+6)|0);
11950       var $5540=$5539;
11951       var $5541=HEAP16[(($5540)>>1)];
11952       var $5542=(($5541)&65535);
11953       var $5543=(($5537+($5542<<2))|0);
11954       var $5544=$5543;
11955       var $5545=$5544;
11956       HEAPF32[(($5545)>>2)]=$5534;
11957       __label__ = 245; break;
11958     case 208:
11959       var $5547=$2;
11960       var $5548=(($5547+64)|0);
11961       var $5549=HEAP32[(($5548)>>2)];
11962       var $5550=$st;
11963       var $5551=(($5550+2)|0);
11964       var $5552=$5551;
11965       var $5553=HEAP16[(($5552)>>1)];
11966       var $5554=(($5553)&65535);
11967       var $5555=(($5549+($5554<<2))|0);
11968       var $5556=$5555;
11969       var $5557=$5556;
11970       var $5558=HEAP32[(($5557)>>2)];
11971       var $5559=$5558 & 2147483647;
11972       var $5560=(($5559)|0)!=0;
11973       if ($5560) { __label__ = 209; break; } else { __label__ = 212; break; }
11974     case 209:
11975       var $5562=$st;
11976       var $5563=(($5562+4)|0);
11977       var $5564=$5563;
11978       var $5565=HEAP16[(($5564)>>1)];
11979       var $5566=(($5565 << 16) >> 16);
11980       var $5567=((($5566)-(1))|0);
11981       var $5568=$st;
11982       var $5569=(($5568+($5567<<3))|0);
11983       $st=$5569;
11984       var $5570=$jumpcount;
11985       var $5571=((($5570)+(1))|0);
11986       $jumpcount=$5571;
11987       var $5572=$5;
11988       var $5573=(($5571)|0) >= (($5572)|0);
11989       if ($5573) { __label__ = 210; break; } else { __label__ = 211; break; }
11990     case 210:
11991       var $5575=$2;
11992       var $5576=$2;
11993       var $5577=(($5576)|0);
11994       var $5578=HEAP32[(($5577)>>2)];
11995       var $5579=$jumpcount;
11996       _qcvmerror($5575, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5578,HEAP32[(((tempInt)+(4))>>2)]=$5579,tempInt));
11997       __label__ = 211; break;
11998     case 211:
11999       __label__ = 212; break;
12000     case 212:
12001       __label__ = 245; break;
12002     case 213:
12003       var $5583=$2;
12004       var $5584=(($5583+64)|0);
12005       var $5585=HEAP32[(($5584)>>2)];
12006       var $5586=$st;
12007       var $5587=(($5586+2)|0);
12008       var $5588=$5587;
12009       var $5589=HEAP16[(($5588)>>1)];
12010       var $5590=(($5589)&65535);
12011       var $5591=(($5585+($5590<<2))|0);
12012       var $5592=$5591;
12013       var $5593=$5592;
12014       var $5594=HEAP32[(($5593)>>2)];
12015       var $5595=$5594 & 2147483647;
12016       var $5596=(($5595)|0)!=0;
12017       if ($5596) { __label__ = 217; break; } else { __label__ = 214; break; }
12018     case 214:
12019       var $5598=$st;
12020       var $5599=(($5598+4)|0);
12021       var $5600=$5599;
12022       var $5601=HEAP16[(($5600)>>1)];
12023       var $5602=(($5601 << 16) >> 16);
12024       var $5603=((($5602)-(1))|0);
12025       var $5604=$st;
12026       var $5605=(($5604+($5603<<3))|0);
12027       $st=$5605;
12028       var $5606=$jumpcount;
12029       var $5607=((($5606)+(1))|0);
12030       $jumpcount=$5607;
12031       var $5608=$5;
12032       var $5609=(($5607)|0) >= (($5608)|0);
12033       if ($5609) { __label__ = 215; break; } else { __label__ = 216; break; }
12034     case 215:
12035       var $5611=$2;
12036       var $5612=$2;
12037       var $5613=(($5612)|0);
12038       var $5614=HEAP32[(($5613)>>2)];
12039       var $5615=$jumpcount;
12040       _qcvmerror($5611, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5614,HEAP32[(((tempInt)+(4))>>2)]=$5615,tempInt));
12041       __label__ = 216; break;
12042     case 216:
12043       __label__ = 217; break;
12044     case 217:
12045       __label__ = 245; break;
12046     case 218:
12047       var $5619=$st;
12048       var $5620=(($5619)|0);
12049       var $5621=HEAP16[(($5620)>>1)];
12050       var $5622=(($5621)&65535);
12051       var $5623=((($5622)-(51))|0);
12052       var $5624=$2;
12053       var $5625=(($5624+184)|0);
12054       HEAP32[(($5625)>>2)]=$5623;
12055       var $5626=$2;
12056       var $5627=(($5626+64)|0);
12057       var $5628=HEAP32[(($5627)>>2)];
12058       var $5629=$st;
12059       var $5630=(($5629+2)|0);
12060       var $5631=$5630;
12061       var $5632=HEAP16[(($5631)>>1)];
12062       var $5633=(($5632)&65535);
12063       var $5634=(($5628+($5633<<2))|0);
12064       var $5635=$5634;
12065       var $5636=$5635;
12066       var $5637=HEAP32[(($5636)>>2)];
12067       var $5638=(($5637)|0)!=0;
12068       if ($5638) { __label__ = 220; break; } else { __label__ = 219; break; }
12069     case 219:
12070       var $5640=$2;
12071       var $5641=$2;
12072       var $5642=(($5641)|0);
12073       var $5643=HEAP32[(($5642)>>2)];
12074       _qcvmerror($5640, ((STRING_TABLE.__str23)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5643,tempInt));
12075       __label__ = 220; break;
12076     case 220:
12077       var $5645=$2;
12078       var $5646=(($5645+64)|0);
12079       var $5647=HEAP32[(($5646)>>2)];
12080       var $5648=$st;
12081       var $5649=(($5648+2)|0);
12082       var $5650=$5649;
12083       var $5651=HEAP16[(($5650)>>1)];
12084       var $5652=(($5651)&65535);
12085       var $5653=(($5647+($5652<<2))|0);
12086       var $5654=$5653;
12087       var $5655=$5654;
12088       var $5656=HEAP32[(($5655)>>2)];
12089       var $5657=(($5656)|0)!=0;
12090       if ($5657) { __label__ = 221; break; } else { __label__ = 222; break; }
12091     case 221:
12092       var $5659=$2;
12093       var $5660=(($5659+64)|0);
12094       var $5661=HEAP32[(($5660)>>2)];
12095       var $5662=$st;
12096       var $5663=(($5662+2)|0);
12097       var $5664=$5663;
12098       var $5665=HEAP16[(($5664)>>1)];
12099       var $5666=(($5665)&65535);
12100       var $5667=(($5661+($5666<<2))|0);
12101       var $5668=$5667;
12102       var $5669=$5668;
12103       var $5670=HEAP32[(($5669)>>2)];
12104       var $5671=$2;
12105       var $5672=(($5671+44)|0);
12106       var $5673=HEAP32[(($5672)>>2)];
12107       var $5674=(($5670)>>>0) >= (($5673)>>>0);
12108       if ($5674) { __label__ = 222; break; } else { __label__ = 223; break; }
12109     case 222:
12110       var $5676=$2;
12111       var $5677=$2;
12112       var $5678=(($5677)|0);
12113       var $5679=HEAP32[(($5678)>>2)];
12114       _qcvmerror($5676, ((STRING_TABLE.__str24)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5679,tempInt));
12115       __label__ = 488; break;
12116     case 223:
12117       var $5681=$2;
12118       var $5682=(($5681+64)|0);
12119       var $5683=HEAP32[(($5682)>>2)];
12120       var $5684=$st;
12121       var $5685=(($5684+2)|0);
12122       var $5686=$5685;
12123       var $5687=HEAP16[(($5686)>>1)];
12124       var $5688=(($5687)&65535);
12125       var $5689=(($5683+($5688<<2))|0);
12126       var $5690=$5689;
12127       var $5691=$5690;
12128       var $5692=HEAP32[(($5691)>>2)];
12129       var $5693=$2;
12130       var $5694=(($5693+40)|0);
12131       var $5695=HEAP32[(($5694)>>2)];
12132       var $5696=(($5695+($5692)*(36))|0);
12133       $newf1=$5696;
12134       var $5697=$newf1;
12135       var $5698=(($5697+12)|0);
12136       var $5699=HEAP32[(($5698)>>2)];
12137       var $5700=((($5699)+(1))|0);
12138       HEAP32[(($5698)>>2)]=$5700;
12139       var $5701=$st;
12140       var $5702=$2;
12141       var $5703=(($5702+4)|0);
12142       var $5704=HEAP32[(($5703)>>2)];
12143       var $5705=$5701;
12144       var $5706=$5704;
12145       var $5707=((($5705)-($5706))|0);
12146       var $5708=((((($5707)|0))/(8))&-1);
12147       var $5709=((($5708)+(1))|0);
12148       var $5710=$2;
12149       var $5711=(($5710+176)|0);
12150       HEAP32[(($5711)>>2)]=$5709;
12151       var $5712=$newf1;
12152       var $5713=(($5712)|0);
12153       var $5714=HEAP32[(($5713)>>2)];
12154       var $5715=(($5714)|0) < 0;
12155       if ($5715) { __label__ = 224; break; } else { __label__ = 229; break; }
12156     case 224:
12157       var $5717=$newf1;
12158       var $5718=(($5717)|0);
12159       var $5719=HEAP32[(($5718)>>2)];
12160       var $5720=(((-$5719))|0);
12161       $builtinnumber4=$5720;
12162       var $5721=$builtinnumber4;
12163       var $5722=$2;
12164       var $5723=(($5722+132)|0);
12165       var $5724=HEAP32[(($5723)>>2)];
12166       var $5725=(($5721)>>>0) < (($5724)>>>0);
12167       if ($5725) { __label__ = 225; break; } else { __label__ = 227; break; }
12168     case 225:
12169       var $5727=$builtinnumber4;
12170       var $5728=$2;
12171       var $5729=(($5728+128)|0);
12172       var $5730=HEAP32[(($5729)>>2)];
12173       var $5731=(($5730+($5727<<2))|0);
12174       var $5732=HEAP32[(($5731)>>2)];
12175       var $5733=(($5732)|0)!=0;
12176       if ($5733) { __label__ = 226; break; } else { __label__ = 227; break; }
12177     case 226:
12178       var $5735=$builtinnumber4;
12179       var $5736=$2;
12180       var $5737=(($5736+128)|0);
12181       var $5738=HEAP32[(($5737)>>2)];
12182       var $5739=(($5738+($5735<<2))|0);
12183       var $5740=HEAP32[(($5739)>>2)];
12184       var $5741=$2;
12185       var $5742=FUNCTION_TABLE[$5740]($5741);
12186       __label__ = 228; break;
12187     case 227:
12188       var $5744=$2;
12189       var $5745=$builtinnumber4;
12190       var $5746=$2;
12191       var $5747=(($5746)|0);
12192       var $5748=HEAP32[(($5747)>>2)];
12193       _qcvmerror($5744, ((STRING_TABLE.__str25)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5745,HEAP32[(((tempInt)+(4))>>2)]=$5748,tempInt));
12194       __label__ = 228; break;
12195     case 228:
12196       __label__ = 230; break;
12197     case 229:
12198       var $5751=$2;
12199       var $5752=(($5751+4)|0);
12200       var $5753=HEAP32[(($5752)>>2)];
12201       var $5754=$2;
12202       var $5755=$newf1;
12203       var $5756=_prog_enterfunction($5754, $5755);
12204       var $5757=(($5753+($5756<<3))|0);
12205       var $5758=((($5757)-(8))|0);
12206       $st=$5758;
12207       __label__ = 230; break;
12208     case 230:
12209       var $5760=$2;
12210       var $5761=(($5760+112)|0);
12211       var $5762=HEAP32[(($5761)>>2)];
12212       var $5763=(($5762)|0)!=0;
12213       if ($5763) { __label__ = 231; break; } else { __label__ = 232; break; }
12214     case 231:
12215       __label__ = 488; break;
12216     case 232:
12217       __label__ = 245; break;
12218     case 233:
12219       var $5767=$2;
12220       var $5768=$2;
12221       var $5769=(($5768)|0);
12222       var $5770=HEAP32[(($5769)>>2)];
12223       _qcvmerror($5767, ((STRING_TABLE.__str26)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5770,tempInt));
12224       __label__ = 245; break;
12225     case 234:
12226       var $5772=$st;
12227       var $5773=(($5772+2)|0);
12228       var $5774=$5773;
12229       var $5775=HEAP16[(($5774)>>1)];
12230       var $5776=(($5775 << 16) >> 16);
12231       var $5777=((($5776)-(1))|0);
12232       var $5778=$st;
12233       var $5779=(($5778+($5777<<3))|0);
12234       $st=$5779;
12235       var $5780=$jumpcount;
12236       var $5781=((($5780)+(1))|0);
12237       $jumpcount=$5781;
12238       var $5782=(($5781)|0)==10000000;
12239       if ($5782) { __label__ = 235; break; } else { __label__ = 236; break; }
12240     case 235:
12241       var $5784=$2;
12242       var $5785=$2;
12243       var $5786=(($5785)|0);
12244       var $5787=HEAP32[(($5786)>>2)];
12245       var $5788=$jumpcount;
12246       _qcvmerror($5784, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5787,HEAP32[(((tempInt)+(4))>>2)]=$5788,tempInt));
12247       __label__ = 236; break;
12248     case 236:
12249       __label__ = 245; break;
12250     case 237:
12251       var $5791=$2;
12252       var $5792=(($5791+64)|0);
12253       var $5793=HEAP32[(($5792)>>2)];
12254       var $5794=$st;
12255       var $5795=(($5794+2)|0);
12256       var $5796=$5795;
12257       var $5797=HEAP16[(($5796)>>1)];
12258       var $5798=(($5797)&65535);
12259       var $5799=(($5793+($5798<<2))|0);
12260       var $5800=$5799;
12261       var $5801=$5800;
12262       var $5802=HEAP32[(($5801)>>2)];
12263       var $5803=$5802 & 2147483647;
12264       var $5804=(($5803)|0)!=0;
12265       if ($5804) { __label__ = 238; break; } else { var $5821 = 0;__label__ = 239; break; }
12266     case 238:
12267       var $5806=$2;
12268       var $5807=(($5806+64)|0);
12269       var $5808=HEAP32[(($5807)>>2)];
12270       var $5809=$st;
12271       var $5810=(($5809+4)|0);
12272       var $5811=$5810;
12273       var $5812=HEAP16[(($5811)>>1)];
12274       var $5813=(($5812)&65535);
12275       var $5814=(($5808+($5813<<2))|0);
12276       var $5815=$5814;
12277       var $5816=$5815;
12278       var $5817=HEAP32[(($5816)>>2)];
12279       var $5818=$5817 & 2147483647;
12280       var $5819=(($5818)|0)!=0;
12281       var $5821 = $5819;__label__ = 239; break;
12282     case 239:
12283       var $5821;
12284       var $5822=(($5821)&1);
12285       var $5823=(($5822)|0);
12286       var $5824=$2;
12287       var $5825=(($5824+64)|0);
12288       var $5826=HEAP32[(($5825)>>2)];
12289       var $5827=$st;
12290       var $5828=(($5827+6)|0);
12291       var $5829=$5828;
12292       var $5830=HEAP16[(($5829)>>1)];
12293       var $5831=(($5830)&65535);
12294       var $5832=(($5826+($5831<<2))|0);
12295       var $5833=$5832;
12296       var $5834=$5833;
12297       HEAPF32[(($5834)>>2)]=$5823;
12298       __label__ = 245; break;
12299     case 240:
12300       var $5836=$2;
12301       var $5837=(($5836+64)|0);
12302       var $5838=HEAP32[(($5837)>>2)];
12303       var $5839=$st;
12304       var $5840=(($5839+2)|0);
12305       var $5841=$5840;
12306       var $5842=HEAP16[(($5841)>>1)];
12307       var $5843=(($5842)&65535);
12308       var $5844=(($5838+($5843<<2))|0);
12309       var $5845=$5844;
12310       var $5846=$5845;
12311       var $5847=HEAP32[(($5846)>>2)];
12312       var $5848=$5847 & 2147483647;
12313       var $5849=(($5848)|0)!=0;
12314       if ($5849) { var $5866 = 1;__label__ = 242; break; } else { __label__ = 241; break; }
12315     case 241:
12316       var $5851=$2;
12317       var $5852=(($5851+64)|0);
12318       var $5853=HEAP32[(($5852)>>2)];
12319       var $5854=$st;
12320       var $5855=(($5854+4)|0);
12321       var $5856=$5855;
12322       var $5857=HEAP16[(($5856)>>1)];
12323       var $5858=(($5857)&65535);
12324       var $5859=(($5853+($5858<<2))|0);
12325       var $5860=$5859;
12326       var $5861=$5860;
12327       var $5862=HEAP32[(($5861)>>2)];
12328       var $5863=$5862 & 2147483647;
12329       var $5864=(($5863)|0)!=0;
12330       var $5866 = $5864;__label__ = 242; break;
12331     case 242:
12332       var $5866;
12333       var $5867=(($5866)&1);
12334       var $5868=(($5867)|0);
12335       var $5869=$2;
12336       var $5870=(($5869+64)|0);
12337       var $5871=HEAP32[(($5870)>>2)];
12338       var $5872=$st;
12339       var $5873=(($5872+6)|0);
12340       var $5874=$5873;
12341       var $5875=HEAP16[(($5874)>>1)];
12342       var $5876=(($5875)&65535);
12343       var $5877=(($5871+($5876<<2))|0);
12344       var $5878=$5877;
12345       var $5879=$5878;
12346       HEAPF32[(($5879)>>2)]=$5868;
12347       __label__ = 245; break;
12348     case 243:
12349       var $5881=$2;
12350       var $5882=(($5881+64)|0);
12351       var $5883=HEAP32[(($5882)>>2)];
12352       var $5884=$st;
12353       var $5885=(($5884+2)|0);
12354       var $5886=$5885;
12355       var $5887=HEAP16[(($5886)>>1)];
12356       var $5888=(($5887)&65535);
12357       var $5889=(($5883+($5888<<2))|0);
12358       var $5890=$5889;
12359       var $5891=$5890;
12360       var $5892=HEAPF32[(($5891)>>2)];
12361       var $5893=(($5892)&-1);
12362       var $5894=$2;
12363       var $5895=(($5894+64)|0);
12364       var $5896=HEAP32[(($5895)>>2)];
12365       var $5897=$st;
12366       var $5898=(($5897+4)|0);
12367       var $5899=$5898;
12368       var $5900=HEAP16[(($5899)>>1)];
12369       var $5901=(($5900)&65535);
12370       var $5902=(($5896+($5901<<2))|0);
12371       var $5903=$5902;
12372       var $5904=$5903;
12373       var $5905=HEAPF32[(($5904)>>2)];
12374       var $5906=(($5905)&-1);
12375       var $5907=$5893 & $5906;
12376       var $5908=(($5907)|0);
12377       var $5909=$2;
12378       var $5910=(($5909+64)|0);
12379       var $5911=HEAP32[(($5910)>>2)];
12380       var $5912=$st;
12381       var $5913=(($5912+6)|0);
12382       var $5914=$5913;
12383       var $5915=HEAP16[(($5914)>>1)];
12384       var $5916=(($5915)&65535);
12385       var $5917=(($5911+($5916<<2))|0);
12386       var $5918=$5917;
12387       var $5919=$5918;
12388       HEAPF32[(($5919)>>2)]=$5908;
12389       __label__ = 245; break;
12390     case 244:
12391       var $5921=$2;
12392       var $5922=(($5921+64)|0);
12393       var $5923=HEAP32[(($5922)>>2)];
12394       var $5924=$st;
12395       var $5925=(($5924+2)|0);
12396       var $5926=$5925;
12397       var $5927=HEAP16[(($5926)>>1)];
12398       var $5928=(($5927)&65535);
12399       var $5929=(($5923+($5928<<2))|0);
12400       var $5930=$5929;
12401       var $5931=$5930;
12402       var $5932=HEAPF32[(($5931)>>2)];
12403       var $5933=(($5932)&-1);
12404       var $5934=$2;
12405       var $5935=(($5934+64)|0);
12406       var $5936=HEAP32[(($5935)>>2)];
12407       var $5937=$st;
12408       var $5938=(($5937+4)|0);
12409       var $5939=$5938;
12410       var $5940=HEAP16[(($5939)>>1)];
12411       var $5941=(($5940)&65535);
12412       var $5942=(($5936+($5941<<2))|0);
12413       var $5943=$5942;
12414       var $5944=$5943;
12415       var $5945=HEAPF32[(($5944)>>2)];
12416       var $5946=(($5945)&-1);
12417       var $5947=$5933 | $5946;
12418       var $5948=(($5947)|0);
12419       var $5949=$2;
12420       var $5950=(($5949+64)|0);
12421       var $5951=HEAP32[(($5950)>>2)];
12422       var $5952=$st;
12423       var $5953=(($5952+6)|0);
12424       var $5954=$5953;
12425       var $5955=HEAP16[(($5954)>>1)];
12426       var $5956=(($5955)&65535);
12427       var $5957=(($5951+($5956<<2))|0);
12428       var $5958=$5957;
12429       var $5959=$5958;
12430       HEAPF32[(($5959)>>2)]=$5948;
12431       __label__ = 245; break;
12432     case 245:
12433       __label__ = 126; break;
12434     case 246:
12435       __label__ = 247; break;
12436     case 247:
12437       var $5963=$st;
12438       var $5964=(($5963+8)|0);
12439       $st=$5964;
12440       var $5965=$st;
12441       var $5966=$2;
12442       var $5967=(($5966+4)|0);
12443       var $5968=HEAP32[(($5967)>>2)];
12444       var $5969=$5965;
12445       var $5970=$5968;
12446       var $5971=((($5969)-($5970))|0);
12447       var $5972=((((($5971)|0))/(8))&-1);
12448       var $5973=$2;
12449       var $5974=(($5973+116)|0);
12450       var $5975=HEAP32[(($5974)>>2)];
12451       var $5976=(($5975+($5972<<2))|0);
12452       var $5977=HEAP32[(($5976)>>2)];
12453       var $5978=((($5977)+(1))|0);
12454       HEAP32[(($5976)>>2)]=$5978;
12455       var $5979=$st;
12456       var $5980=(($5979)|0);
12457       var $5981=HEAP16[(($5980)>>1)];
12458       var $5982=(($5981)&65535);
12459       if ((($5982)|0) == 0 || (($5982)|0) == 43) {
12460         __label__ = 249; break;
12461       }
12462       else if ((($5982)|0) == 1) {
12463         __label__ = 252; break;
12464       }
12465       else if ((($5982)|0) == 2) {
12466         __label__ = 253; break;
12467       }
12468       else if ((($5982)|0) == 3) {
12469         __label__ = 254; break;
12470       }
12471       else if ((($5982)|0) == 4) {
12472         __label__ = 255; break;
12473       }
12474       else if ((($5982)|0) == 5) {
12475         __label__ = 256; break;
12476       }
12477       else if ((($5982)|0) == 6) {
12478         __label__ = 260; break;
12479       }
12480       else if ((($5982)|0) == 7) {
12481         __label__ = 261; break;
12482       }
12483       else if ((($5982)|0) == 8) {
12484         __label__ = 262; break;
12485       }
12486       else if ((($5982)|0) == 9) {
12487         __label__ = 263; break;
12488       }
12489       else if ((($5982)|0) == 10) {
12490         __label__ = 264; break;
12491       }
12492       else if ((($5982)|0) == 11) {
12493         __label__ = 265; break;
12494       }
12495       else if ((($5982)|0) == 12) {
12496         __label__ = 269; break;
12497       }
12498       else if ((($5982)|0) == 13) {
12499         __label__ = 270; break;
12500       }
12501       else if ((($5982)|0) == 14) {
12502         __label__ = 271; break;
12503       }
12504       else if ((($5982)|0) == 15) {
12505         __label__ = 272; break;
12506       }
12507       else if ((($5982)|0) == 16) {
12508         __label__ = 273; break;
12509       }
12510       else if ((($5982)|0) == 17) {
12511         __label__ = 277; break;
12512       }
12513       else if ((($5982)|0) == 18) {
12514         __label__ = 278; break;
12515       }
12516       else if ((($5982)|0) == 19) {
12517         __label__ = 279; break;
12518       }
12519       else if ((($5982)|0) == 20) {
12520         __label__ = 280; break;
12521       }
12522       else if ((($5982)|0) == 21) {
12523         __label__ = 281; break;
12524       }
12525       else if ((($5982)|0) == 22) {
12526         __label__ = 282; break;
12527       }
12528       else if ((($5982)|0) == 23) {
12529         __label__ = 283; break;
12530       }
12531       else if ((($5982)|0) == 24 || (($5982)|0) == 26 || (($5982)|0) == 28 || (($5982)|0) == 27 || (($5982)|0) == 29) {
12532         __label__ = 284; break;
12533       }
12534       else if ((($5982)|0) == 25) {
12535         __label__ = 290; break;
12536       }
12537       else if ((($5982)|0) == 30) {
12538         __label__ = 297; break;
12539       }
12540       else if ((($5982)|0) == 31 || (($5982)|0) == 33 || (($5982)|0) == 34 || (($5982)|0) == 35 || (($5982)|0) == 36) {
12541         __label__ = 303; break;
12542       }
12543       else if ((($5982)|0) == 32) {
12544         __label__ = 304; break;
12545       }
12546       else if ((($5982)|0) == 37 || (($5982)|0) == 39 || (($5982)|0) == 40 || (($5982)|0) == 41 || (($5982)|0) == 42) {
12547         __label__ = 305; break;
12548       }
12549       else if ((($5982)|0) == 38) {
12550         __label__ = 312; break;
12551       }
12552       else if ((($5982)|0) == 44) {
12553         __label__ = 319; break;
12554       }
12555       else if ((($5982)|0) == 45) {
12556         __label__ = 320; break;
12557       }
12558       else if ((($5982)|0) == 46) {
12559         __label__ = 324; break;
12560       }
12561       else if ((($5982)|0) == 47) {
12562         __label__ = 327; break;
12563       }
12564       else if ((($5982)|0) == 48) {
12565         __label__ = 328; break;
12566       }
12567       else if ((($5982)|0) == 49) {
12568         __label__ = 329; break;
12569       }
12570       else if ((($5982)|0) == 50) {
12571         __label__ = 334; break;
12572       }
12573       else if ((($5982)|0) == 51 || (($5982)|0) == 52 || (($5982)|0) == 53 || (($5982)|0) == 54 || (($5982)|0) == 55 || (($5982)|0) == 56 || (($5982)|0) == 57 || (($5982)|0) == 58 || (($5982)|0) == 59) {
12574         __label__ = 339; break;
12575       }
12576       else if ((($5982)|0) == 60) {
12577         __label__ = 354; break;
12578       }
12579       else if ((($5982)|0) == 61) {
12580         __label__ = 355; break;
12581       }
12582       else if ((($5982)|0) == 62) {
12583         __label__ = 358; break;
12584       }
12585       else if ((($5982)|0) == 63) {
12586         __label__ = 361; break;
12587       }
12588       else if ((($5982)|0) == 64) {
12589         __label__ = 364; break;
12590       }
12591       else if ((($5982)|0) == 65) {
12592         __label__ = 365; break;
12593       }
12594       else {
12595       __label__ = 248; break;
12596       }
12597
12598     case 248:
12599       var $5984=$2;
12600       var $5985=$2;
12601       var $5986=(($5985)|0);
12602       var $5987=HEAP32[(($5986)>>2)];
12603       _qcvmerror($5984, ((STRING_TABLE.__str16)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5987,tempInt));
12604       __label__ = 488; break;
12605     case 249:
12606       var $5989=$2;
12607       var $5990=(($5989+64)|0);
12608       var $5991=HEAP32[(($5990)>>2)];
12609       var $5992=$st;
12610       var $5993=(($5992+2)|0);
12611       var $5994=$5993;
12612       var $5995=HEAP16[(($5994)>>1)];
12613       var $5996=(($5995)&65535);
12614       var $5997=(($5991+($5996<<2))|0);
12615       var $5998=$5997;
12616       var $5999=$5998;
12617       var $6000=(($5999)|0);
12618       var $6001=HEAP32[(($6000)>>2)];
12619       var $6002=$2;
12620       var $6003=(($6002+64)|0);
12621       var $6004=HEAP32[(($6003)>>2)];
12622       var $6005=(($6004+4)|0);
12623       var $6006=$6005;
12624       var $6007=$6006;
12625       var $6008=(($6007)|0);
12626       HEAP32[(($6008)>>2)]=$6001;
12627       var $6009=$2;
12628       var $6010=(($6009+64)|0);
12629       var $6011=HEAP32[(($6010)>>2)];
12630       var $6012=$st;
12631       var $6013=(($6012+2)|0);
12632       var $6014=$6013;
12633       var $6015=HEAP16[(($6014)>>1)];
12634       var $6016=(($6015)&65535);
12635       var $6017=(($6011+($6016<<2))|0);
12636       var $6018=$6017;
12637       var $6019=$6018;
12638       var $6020=(($6019+4)|0);
12639       var $6021=HEAP32[(($6020)>>2)];
12640       var $6022=$2;
12641       var $6023=(($6022+64)|0);
12642       var $6024=HEAP32[(($6023)>>2)];
12643       var $6025=(($6024+4)|0);
12644       var $6026=$6025;
12645       var $6027=$6026;
12646       var $6028=(($6027+4)|0);
12647       HEAP32[(($6028)>>2)]=$6021;
12648       var $6029=$2;
12649       var $6030=(($6029+64)|0);
12650       var $6031=HEAP32[(($6030)>>2)];
12651       var $6032=$st;
12652       var $6033=(($6032+2)|0);
12653       var $6034=$6033;
12654       var $6035=HEAP16[(($6034)>>1)];
12655       var $6036=(($6035)&65535);
12656       var $6037=(($6031+($6036<<2))|0);
12657       var $6038=$6037;
12658       var $6039=$6038;
12659       var $6040=(($6039+8)|0);
12660       var $6041=HEAP32[(($6040)>>2)];
12661       var $6042=$2;
12662       var $6043=(($6042+64)|0);
12663       var $6044=HEAP32[(($6043)>>2)];
12664       var $6045=(($6044+4)|0);
12665       var $6046=$6045;
12666       var $6047=$6046;
12667       var $6048=(($6047+8)|0);
12668       HEAP32[(($6048)>>2)]=$6041;
12669       var $6049=$2;
12670       var $6050=(($6049+4)|0);
12671       var $6051=HEAP32[(($6050)>>2)];
12672       var $6052=$2;
12673       var $6053=_prog_leavefunction($6052);
12674       var $6054=(($6051+($6053<<3))|0);
12675       $st=$6054;
12676       var $6055=$2;
12677       var $6056=(($6055+168)|0);
12678       var $6057=HEAP32[(($6056)>>2)];
12679       var $6058=(($6057)|0)!=0;
12680       if ($6058) { __label__ = 251; break; } else { __label__ = 250; break; }
12681     case 250:
12682       __label__ = 488; break;
12683     case 251:
12684       __label__ = 366; break;
12685     case 252:
12686       var $6062=$2;
12687       var $6063=(($6062+64)|0);
12688       var $6064=HEAP32[(($6063)>>2)];
12689       var $6065=$st;
12690       var $6066=(($6065+2)|0);
12691       var $6067=$6066;
12692       var $6068=HEAP16[(($6067)>>1)];
12693       var $6069=(($6068)&65535);
12694       var $6070=(($6064+($6069<<2))|0);
12695       var $6071=$6070;
12696       var $6072=$6071;
12697       var $6073=HEAPF32[(($6072)>>2)];
12698       var $6074=$2;
12699       var $6075=(($6074+64)|0);
12700       var $6076=HEAP32[(($6075)>>2)];
12701       var $6077=$st;
12702       var $6078=(($6077+4)|0);
12703       var $6079=$6078;
12704       var $6080=HEAP16[(($6079)>>1)];
12705       var $6081=(($6080)&65535);
12706       var $6082=(($6076+($6081<<2))|0);
12707       var $6083=$6082;
12708       var $6084=$6083;
12709       var $6085=HEAPF32[(($6084)>>2)];
12710       var $6086=($6073)*($6085);
12711       var $6087=$2;
12712       var $6088=(($6087+64)|0);
12713       var $6089=HEAP32[(($6088)>>2)];
12714       var $6090=$st;
12715       var $6091=(($6090+6)|0);
12716       var $6092=$6091;
12717       var $6093=HEAP16[(($6092)>>1)];
12718       var $6094=(($6093)&65535);
12719       var $6095=(($6089+($6094<<2))|0);
12720       var $6096=$6095;
12721       var $6097=$6096;
12722       HEAPF32[(($6097)>>2)]=$6086;
12723       __label__ = 366; break;
12724     case 253:
12725       var $6099=$2;
12726       var $6100=(($6099+64)|0);
12727       var $6101=HEAP32[(($6100)>>2)];
12728       var $6102=$st;
12729       var $6103=(($6102+2)|0);
12730       var $6104=$6103;
12731       var $6105=HEAP16[(($6104)>>1)];
12732       var $6106=(($6105)&65535);
12733       var $6107=(($6101+($6106<<2))|0);
12734       var $6108=$6107;
12735       var $6109=$6108;
12736       var $6110=(($6109)|0);
12737       var $6111=HEAPF32[(($6110)>>2)];
12738       var $6112=$2;
12739       var $6113=(($6112+64)|0);
12740       var $6114=HEAP32[(($6113)>>2)];
12741       var $6115=$st;
12742       var $6116=(($6115+4)|0);
12743       var $6117=$6116;
12744       var $6118=HEAP16[(($6117)>>1)];
12745       var $6119=(($6118)&65535);
12746       var $6120=(($6114+($6119<<2))|0);
12747       var $6121=$6120;
12748       var $6122=$6121;
12749       var $6123=(($6122)|0);
12750       var $6124=HEAPF32[(($6123)>>2)];
12751       var $6125=($6111)*($6124);
12752       var $6126=$2;
12753       var $6127=(($6126+64)|0);
12754       var $6128=HEAP32[(($6127)>>2)];
12755       var $6129=$st;
12756       var $6130=(($6129+2)|0);
12757       var $6131=$6130;
12758       var $6132=HEAP16[(($6131)>>1)];
12759       var $6133=(($6132)&65535);
12760       var $6134=(($6128+($6133<<2))|0);
12761       var $6135=$6134;
12762       var $6136=$6135;
12763       var $6137=(($6136+4)|0);
12764       var $6138=HEAPF32[(($6137)>>2)];
12765       var $6139=$2;
12766       var $6140=(($6139+64)|0);
12767       var $6141=HEAP32[(($6140)>>2)];
12768       var $6142=$st;
12769       var $6143=(($6142+4)|0);
12770       var $6144=$6143;
12771       var $6145=HEAP16[(($6144)>>1)];
12772       var $6146=(($6145)&65535);
12773       var $6147=(($6141+($6146<<2))|0);
12774       var $6148=$6147;
12775       var $6149=$6148;
12776       var $6150=(($6149+4)|0);
12777       var $6151=HEAPF32[(($6150)>>2)];
12778       var $6152=($6138)*($6151);
12779       var $6153=($6125)+($6152);
12780       var $6154=$2;
12781       var $6155=(($6154+64)|0);
12782       var $6156=HEAP32[(($6155)>>2)];
12783       var $6157=$st;
12784       var $6158=(($6157+2)|0);
12785       var $6159=$6158;
12786       var $6160=HEAP16[(($6159)>>1)];
12787       var $6161=(($6160)&65535);
12788       var $6162=(($6156+($6161<<2))|0);
12789       var $6163=$6162;
12790       var $6164=$6163;
12791       var $6165=(($6164+8)|0);
12792       var $6166=HEAPF32[(($6165)>>2)];
12793       var $6167=$2;
12794       var $6168=(($6167+64)|0);
12795       var $6169=HEAP32[(($6168)>>2)];
12796       var $6170=$st;
12797       var $6171=(($6170+4)|0);
12798       var $6172=$6171;
12799       var $6173=HEAP16[(($6172)>>1)];
12800       var $6174=(($6173)&65535);
12801       var $6175=(($6169+($6174<<2))|0);
12802       var $6176=$6175;
12803       var $6177=$6176;
12804       var $6178=(($6177+8)|0);
12805       var $6179=HEAPF32[(($6178)>>2)];
12806       var $6180=($6166)*($6179);
12807       var $6181=($6153)+($6180);
12808       var $6182=$2;
12809       var $6183=(($6182+64)|0);
12810       var $6184=HEAP32[(($6183)>>2)];
12811       var $6185=$st;
12812       var $6186=(($6185+6)|0);
12813       var $6187=$6186;
12814       var $6188=HEAP16[(($6187)>>1)];
12815       var $6189=(($6188)&65535);
12816       var $6190=(($6184+($6189<<2))|0);
12817       var $6191=$6190;
12818       var $6192=$6191;
12819       HEAPF32[(($6192)>>2)]=$6181;
12820       __label__ = 366; break;
12821     case 254:
12822       var $6194=$2;
12823       var $6195=(($6194+64)|0);
12824       var $6196=HEAP32[(($6195)>>2)];
12825       var $6197=$st;
12826       var $6198=(($6197+2)|0);
12827       var $6199=$6198;
12828       var $6200=HEAP16[(($6199)>>1)];
12829       var $6201=(($6200)&65535);
12830       var $6202=(($6196+($6201<<2))|0);
12831       var $6203=$6202;
12832       var $6204=$6203;
12833       var $6205=HEAPF32[(($6204)>>2)];
12834       var $6206=$2;
12835       var $6207=(($6206+64)|0);
12836       var $6208=HEAP32[(($6207)>>2)];
12837       var $6209=$st;
12838       var $6210=(($6209+4)|0);
12839       var $6211=$6210;
12840       var $6212=HEAP16[(($6211)>>1)];
12841       var $6213=(($6212)&65535);
12842       var $6214=(($6208+($6213<<2))|0);
12843       var $6215=$6214;
12844       var $6216=$6215;
12845       var $6217=(($6216)|0);
12846       var $6218=HEAPF32[(($6217)>>2)];
12847       var $6219=($6205)*($6218);
12848       var $6220=$2;
12849       var $6221=(($6220+64)|0);
12850       var $6222=HEAP32[(($6221)>>2)];
12851       var $6223=$st;
12852       var $6224=(($6223+6)|0);
12853       var $6225=$6224;
12854       var $6226=HEAP16[(($6225)>>1)];
12855       var $6227=(($6226)&65535);
12856       var $6228=(($6222+($6227<<2))|0);
12857       var $6229=$6228;
12858       var $6230=$6229;
12859       var $6231=(($6230)|0);
12860       HEAPF32[(($6231)>>2)]=$6219;
12861       var $6232=$2;
12862       var $6233=(($6232+64)|0);
12863       var $6234=HEAP32[(($6233)>>2)];
12864       var $6235=$st;
12865       var $6236=(($6235+2)|0);
12866       var $6237=$6236;
12867       var $6238=HEAP16[(($6237)>>1)];
12868       var $6239=(($6238)&65535);
12869       var $6240=(($6234+($6239<<2))|0);
12870       var $6241=$6240;
12871       var $6242=$6241;
12872       var $6243=HEAPF32[(($6242)>>2)];
12873       var $6244=$2;
12874       var $6245=(($6244+64)|0);
12875       var $6246=HEAP32[(($6245)>>2)];
12876       var $6247=$st;
12877       var $6248=(($6247+4)|0);
12878       var $6249=$6248;
12879       var $6250=HEAP16[(($6249)>>1)];
12880       var $6251=(($6250)&65535);
12881       var $6252=(($6246+($6251<<2))|0);
12882       var $6253=$6252;
12883       var $6254=$6253;
12884       var $6255=(($6254+4)|0);
12885       var $6256=HEAPF32[(($6255)>>2)];
12886       var $6257=($6243)*($6256);
12887       var $6258=$2;
12888       var $6259=(($6258+64)|0);
12889       var $6260=HEAP32[(($6259)>>2)];
12890       var $6261=$st;
12891       var $6262=(($6261+6)|0);
12892       var $6263=$6262;
12893       var $6264=HEAP16[(($6263)>>1)];
12894       var $6265=(($6264)&65535);
12895       var $6266=(($6260+($6265<<2))|0);
12896       var $6267=$6266;
12897       var $6268=$6267;
12898       var $6269=(($6268+4)|0);
12899       HEAPF32[(($6269)>>2)]=$6257;
12900       var $6270=$2;
12901       var $6271=(($6270+64)|0);
12902       var $6272=HEAP32[(($6271)>>2)];
12903       var $6273=$st;
12904       var $6274=(($6273+2)|0);
12905       var $6275=$6274;
12906       var $6276=HEAP16[(($6275)>>1)];
12907       var $6277=(($6276)&65535);
12908       var $6278=(($6272+($6277<<2))|0);
12909       var $6279=$6278;
12910       var $6280=$6279;
12911       var $6281=HEAPF32[(($6280)>>2)];
12912       var $6282=$2;
12913       var $6283=(($6282+64)|0);
12914       var $6284=HEAP32[(($6283)>>2)];
12915       var $6285=$st;
12916       var $6286=(($6285+4)|0);
12917       var $6287=$6286;
12918       var $6288=HEAP16[(($6287)>>1)];
12919       var $6289=(($6288)&65535);
12920       var $6290=(($6284+($6289<<2))|0);
12921       var $6291=$6290;
12922       var $6292=$6291;
12923       var $6293=(($6292+8)|0);
12924       var $6294=HEAPF32[(($6293)>>2)];
12925       var $6295=($6281)*($6294);
12926       var $6296=$2;
12927       var $6297=(($6296+64)|0);
12928       var $6298=HEAP32[(($6297)>>2)];
12929       var $6299=$st;
12930       var $6300=(($6299+6)|0);
12931       var $6301=$6300;
12932       var $6302=HEAP16[(($6301)>>1)];
12933       var $6303=(($6302)&65535);
12934       var $6304=(($6298+($6303<<2))|0);
12935       var $6305=$6304;
12936       var $6306=$6305;
12937       var $6307=(($6306+8)|0);
12938       HEAPF32[(($6307)>>2)]=$6295;
12939       __label__ = 366; break;
12940     case 255:
12941       var $6309=$2;
12942       var $6310=(($6309+64)|0);
12943       var $6311=HEAP32[(($6310)>>2)];
12944       var $6312=$st;
12945       var $6313=(($6312+4)|0);
12946       var $6314=$6313;
12947       var $6315=HEAP16[(($6314)>>1)];
12948       var $6316=(($6315)&65535);
12949       var $6317=(($6311+($6316<<2))|0);
12950       var $6318=$6317;
12951       var $6319=$6318;
12952       var $6320=HEAPF32[(($6319)>>2)];
12953       var $6321=$2;
12954       var $6322=(($6321+64)|0);
12955       var $6323=HEAP32[(($6322)>>2)];
12956       var $6324=$st;
12957       var $6325=(($6324+2)|0);
12958       var $6326=$6325;
12959       var $6327=HEAP16[(($6326)>>1)];
12960       var $6328=(($6327)&65535);
12961       var $6329=(($6323+($6328<<2))|0);
12962       var $6330=$6329;
12963       var $6331=$6330;
12964       var $6332=(($6331)|0);
12965       var $6333=HEAPF32[(($6332)>>2)];
12966       var $6334=($6320)*($6333);
12967       var $6335=$2;
12968       var $6336=(($6335+64)|0);
12969       var $6337=HEAP32[(($6336)>>2)];
12970       var $6338=$st;
12971       var $6339=(($6338+6)|0);
12972       var $6340=$6339;
12973       var $6341=HEAP16[(($6340)>>1)];
12974       var $6342=(($6341)&65535);
12975       var $6343=(($6337+($6342<<2))|0);
12976       var $6344=$6343;
12977       var $6345=$6344;
12978       var $6346=(($6345)|0);
12979       HEAPF32[(($6346)>>2)]=$6334;
12980       var $6347=$2;
12981       var $6348=(($6347+64)|0);
12982       var $6349=HEAP32[(($6348)>>2)];
12983       var $6350=$st;
12984       var $6351=(($6350+4)|0);
12985       var $6352=$6351;
12986       var $6353=HEAP16[(($6352)>>1)];
12987       var $6354=(($6353)&65535);
12988       var $6355=(($6349+($6354<<2))|0);
12989       var $6356=$6355;
12990       var $6357=$6356;
12991       var $6358=HEAPF32[(($6357)>>2)];
12992       var $6359=$2;
12993       var $6360=(($6359+64)|0);
12994       var $6361=HEAP32[(($6360)>>2)];
12995       var $6362=$st;
12996       var $6363=(($6362+2)|0);
12997       var $6364=$6363;
12998       var $6365=HEAP16[(($6364)>>1)];
12999       var $6366=(($6365)&65535);
13000       var $6367=(($6361+($6366<<2))|0);
13001       var $6368=$6367;
13002       var $6369=$6368;
13003       var $6370=(($6369+4)|0);
13004       var $6371=HEAPF32[(($6370)>>2)];
13005       var $6372=($6358)*($6371);
13006       var $6373=$2;
13007       var $6374=(($6373+64)|0);
13008       var $6375=HEAP32[(($6374)>>2)];
13009       var $6376=$st;
13010       var $6377=(($6376+6)|0);
13011       var $6378=$6377;
13012       var $6379=HEAP16[(($6378)>>1)];
13013       var $6380=(($6379)&65535);
13014       var $6381=(($6375+($6380<<2))|0);
13015       var $6382=$6381;
13016       var $6383=$6382;
13017       var $6384=(($6383+4)|0);
13018       HEAPF32[(($6384)>>2)]=$6372;
13019       var $6385=$2;
13020       var $6386=(($6385+64)|0);
13021       var $6387=HEAP32[(($6386)>>2)];
13022       var $6388=$st;
13023       var $6389=(($6388+4)|0);
13024       var $6390=$6389;
13025       var $6391=HEAP16[(($6390)>>1)];
13026       var $6392=(($6391)&65535);
13027       var $6393=(($6387+($6392<<2))|0);
13028       var $6394=$6393;
13029       var $6395=$6394;
13030       var $6396=HEAPF32[(($6395)>>2)];
13031       var $6397=$2;
13032       var $6398=(($6397+64)|0);
13033       var $6399=HEAP32[(($6398)>>2)];
13034       var $6400=$st;
13035       var $6401=(($6400+2)|0);
13036       var $6402=$6401;
13037       var $6403=HEAP16[(($6402)>>1)];
13038       var $6404=(($6403)&65535);
13039       var $6405=(($6399+($6404<<2))|0);
13040       var $6406=$6405;
13041       var $6407=$6406;
13042       var $6408=(($6407+8)|0);
13043       var $6409=HEAPF32[(($6408)>>2)];
13044       var $6410=($6396)*($6409);
13045       var $6411=$2;
13046       var $6412=(($6411+64)|0);
13047       var $6413=HEAP32[(($6412)>>2)];
13048       var $6414=$st;
13049       var $6415=(($6414+6)|0);
13050       var $6416=$6415;
13051       var $6417=HEAP16[(($6416)>>1)];
13052       var $6418=(($6417)&65535);
13053       var $6419=(($6413+($6418<<2))|0);
13054       var $6420=$6419;
13055       var $6421=$6420;
13056       var $6422=(($6421+8)|0);
13057       HEAPF32[(($6422)>>2)]=$6410;
13058       __label__ = 366; break;
13059     case 256:
13060       var $6424=$2;
13061       var $6425=(($6424+64)|0);
13062       var $6426=HEAP32[(($6425)>>2)];
13063       var $6427=$st;
13064       var $6428=(($6427+4)|0);
13065       var $6429=$6428;
13066       var $6430=HEAP16[(($6429)>>1)];
13067       var $6431=(($6430)&65535);
13068       var $6432=(($6426+($6431<<2))|0);
13069       var $6433=$6432;
13070       var $6434=$6433;
13071       var $6435=HEAPF32[(($6434)>>2)];
13072       var $6436=$6435 != 0;
13073       if ($6436) { __label__ = 257; break; } else { __label__ = 258; break; }
13074     case 257:
13075       var $6438=$2;
13076       var $6439=(($6438+64)|0);
13077       var $6440=HEAP32[(($6439)>>2)];
13078       var $6441=$st;
13079       var $6442=(($6441+2)|0);
13080       var $6443=$6442;
13081       var $6444=HEAP16[(($6443)>>1)];
13082       var $6445=(($6444)&65535);
13083       var $6446=(($6440+($6445<<2))|0);
13084       var $6447=$6446;
13085       var $6448=$6447;
13086       var $6449=HEAPF32[(($6448)>>2)];
13087       var $6450=$2;
13088       var $6451=(($6450+64)|0);
13089       var $6452=HEAP32[(($6451)>>2)];
13090       var $6453=$st;
13091       var $6454=(($6453+4)|0);
13092       var $6455=$6454;
13093       var $6456=HEAP16[(($6455)>>1)];
13094       var $6457=(($6456)&65535);
13095       var $6458=(($6452+($6457<<2))|0);
13096       var $6459=$6458;
13097       var $6460=$6459;
13098       var $6461=HEAPF32[(($6460)>>2)];
13099       var $6462=($6449)/($6461);
13100       var $6463=$2;
13101       var $6464=(($6463+64)|0);
13102       var $6465=HEAP32[(($6464)>>2)];
13103       var $6466=$st;
13104       var $6467=(($6466+6)|0);
13105       var $6468=$6467;
13106       var $6469=HEAP16[(($6468)>>1)];
13107       var $6470=(($6469)&65535);
13108       var $6471=(($6465+($6470<<2))|0);
13109       var $6472=$6471;
13110       var $6473=$6472;
13111       HEAPF32[(($6473)>>2)]=$6462;
13112       __label__ = 259; break;
13113     case 258:
13114       var $6475=$2;
13115       var $6476=(($6475+64)|0);
13116       var $6477=HEAP32[(($6476)>>2)];
13117       var $6478=$st;
13118       var $6479=(($6478+6)|0);
13119       var $6480=$6479;
13120       var $6481=HEAP16[(($6480)>>1)];
13121       var $6482=(($6481)&65535);
13122       var $6483=(($6477+($6482<<2))|0);
13123       var $6484=$6483;
13124       var $6485=$6484;
13125       HEAPF32[(($6485)>>2)]=0;
13126       __label__ = 259; break;
13127     case 259:
13128       __label__ = 366; break;
13129     case 260:
13130       var $6488=$2;
13131       var $6489=(($6488+64)|0);
13132       var $6490=HEAP32[(($6489)>>2)];
13133       var $6491=$st;
13134       var $6492=(($6491+2)|0);
13135       var $6493=$6492;
13136       var $6494=HEAP16[(($6493)>>1)];
13137       var $6495=(($6494)&65535);
13138       var $6496=(($6490+($6495<<2))|0);
13139       var $6497=$6496;
13140       var $6498=$6497;
13141       var $6499=HEAPF32[(($6498)>>2)];
13142       var $6500=$2;
13143       var $6501=(($6500+64)|0);
13144       var $6502=HEAP32[(($6501)>>2)];
13145       var $6503=$st;
13146       var $6504=(($6503+4)|0);
13147       var $6505=$6504;
13148       var $6506=HEAP16[(($6505)>>1)];
13149       var $6507=(($6506)&65535);
13150       var $6508=(($6502+($6507<<2))|0);
13151       var $6509=$6508;
13152       var $6510=$6509;
13153       var $6511=HEAPF32[(($6510)>>2)];
13154       var $6512=($6499)+($6511);
13155       var $6513=$2;
13156       var $6514=(($6513+64)|0);
13157       var $6515=HEAP32[(($6514)>>2)];
13158       var $6516=$st;
13159       var $6517=(($6516+6)|0);
13160       var $6518=$6517;
13161       var $6519=HEAP16[(($6518)>>1)];
13162       var $6520=(($6519)&65535);
13163       var $6521=(($6515+($6520<<2))|0);
13164       var $6522=$6521;
13165       var $6523=$6522;
13166       HEAPF32[(($6523)>>2)]=$6512;
13167       __label__ = 366; break;
13168     case 261:
13169       var $6525=$2;
13170       var $6526=(($6525+64)|0);
13171       var $6527=HEAP32[(($6526)>>2)];
13172       var $6528=$st;
13173       var $6529=(($6528+2)|0);
13174       var $6530=$6529;
13175       var $6531=HEAP16[(($6530)>>1)];
13176       var $6532=(($6531)&65535);
13177       var $6533=(($6527+($6532<<2))|0);
13178       var $6534=$6533;
13179       var $6535=$6534;
13180       var $6536=(($6535)|0);
13181       var $6537=HEAPF32[(($6536)>>2)];
13182       var $6538=$2;
13183       var $6539=(($6538+64)|0);
13184       var $6540=HEAP32[(($6539)>>2)];
13185       var $6541=$st;
13186       var $6542=(($6541+4)|0);
13187       var $6543=$6542;
13188       var $6544=HEAP16[(($6543)>>1)];
13189       var $6545=(($6544)&65535);
13190       var $6546=(($6540+($6545<<2))|0);
13191       var $6547=$6546;
13192       var $6548=$6547;
13193       var $6549=(($6548)|0);
13194       var $6550=HEAPF32[(($6549)>>2)];
13195       var $6551=($6537)+($6550);
13196       var $6552=$2;
13197       var $6553=(($6552+64)|0);
13198       var $6554=HEAP32[(($6553)>>2)];
13199       var $6555=$st;
13200       var $6556=(($6555+6)|0);
13201       var $6557=$6556;
13202       var $6558=HEAP16[(($6557)>>1)];
13203       var $6559=(($6558)&65535);
13204       var $6560=(($6554+($6559<<2))|0);
13205       var $6561=$6560;
13206       var $6562=$6561;
13207       var $6563=(($6562)|0);
13208       HEAPF32[(($6563)>>2)]=$6551;
13209       var $6564=$2;
13210       var $6565=(($6564+64)|0);
13211       var $6566=HEAP32[(($6565)>>2)];
13212       var $6567=$st;
13213       var $6568=(($6567+2)|0);
13214       var $6569=$6568;
13215       var $6570=HEAP16[(($6569)>>1)];
13216       var $6571=(($6570)&65535);
13217       var $6572=(($6566+($6571<<2))|0);
13218       var $6573=$6572;
13219       var $6574=$6573;
13220       var $6575=(($6574+4)|0);
13221       var $6576=HEAPF32[(($6575)>>2)];
13222       var $6577=$2;
13223       var $6578=(($6577+64)|0);
13224       var $6579=HEAP32[(($6578)>>2)];
13225       var $6580=$st;
13226       var $6581=(($6580+4)|0);
13227       var $6582=$6581;
13228       var $6583=HEAP16[(($6582)>>1)];
13229       var $6584=(($6583)&65535);
13230       var $6585=(($6579+($6584<<2))|0);
13231       var $6586=$6585;
13232       var $6587=$6586;
13233       var $6588=(($6587+4)|0);
13234       var $6589=HEAPF32[(($6588)>>2)];
13235       var $6590=($6576)+($6589);
13236       var $6591=$2;
13237       var $6592=(($6591+64)|0);
13238       var $6593=HEAP32[(($6592)>>2)];
13239       var $6594=$st;
13240       var $6595=(($6594+6)|0);
13241       var $6596=$6595;
13242       var $6597=HEAP16[(($6596)>>1)];
13243       var $6598=(($6597)&65535);
13244       var $6599=(($6593+($6598<<2))|0);
13245       var $6600=$6599;
13246       var $6601=$6600;
13247       var $6602=(($6601+4)|0);
13248       HEAPF32[(($6602)>>2)]=$6590;
13249       var $6603=$2;
13250       var $6604=(($6603+64)|0);
13251       var $6605=HEAP32[(($6604)>>2)];
13252       var $6606=$st;
13253       var $6607=(($6606+2)|0);
13254       var $6608=$6607;
13255       var $6609=HEAP16[(($6608)>>1)];
13256       var $6610=(($6609)&65535);
13257       var $6611=(($6605+($6610<<2))|0);
13258       var $6612=$6611;
13259       var $6613=$6612;
13260       var $6614=(($6613+8)|0);
13261       var $6615=HEAPF32[(($6614)>>2)];
13262       var $6616=$2;
13263       var $6617=(($6616+64)|0);
13264       var $6618=HEAP32[(($6617)>>2)];
13265       var $6619=$st;
13266       var $6620=(($6619+4)|0);
13267       var $6621=$6620;
13268       var $6622=HEAP16[(($6621)>>1)];
13269       var $6623=(($6622)&65535);
13270       var $6624=(($6618+($6623<<2))|0);
13271       var $6625=$6624;
13272       var $6626=$6625;
13273       var $6627=(($6626+8)|0);
13274       var $6628=HEAPF32[(($6627)>>2)];
13275       var $6629=($6615)+($6628);
13276       var $6630=$2;
13277       var $6631=(($6630+64)|0);
13278       var $6632=HEAP32[(($6631)>>2)];
13279       var $6633=$st;
13280       var $6634=(($6633+6)|0);
13281       var $6635=$6634;
13282       var $6636=HEAP16[(($6635)>>1)];
13283       var $6637=(($6636)&65535);
13284       var $6638=(($6632+($6637<<2))|0);
13285       var $6639=$6638;
13286       var $6640=$6639;
13287       var $6641=(($6640+8)|0);
13288       HEAPF32[(($6641)>>2)]=$6629;
13289       __label__ = 366; break;
13290     case 262:
13291       var $6643=$2;
13292       var $6644=(($6643+64)|0);
13293       var $6645=HEAP32[(($6644)>>2)];
13294       var $6646=$st;
13295       var $6647=(($6646+2)|0);
13296       var $6648=$6647;
13297       var $6649=HEAP16[(($6648)>>1)];
13298       var $6650=(($6649)&65535);
13299       var $6651=(($6645+($6650<<2))|0);
13300       var $6652=$6651;
13301       var $6653=$6652;
13302       var $6654=HEAPF32[(($6653)>>2)];
13303       var $6655=$2;
13304       var $6656=(($6655+64)|0);
13305       var $6657=HEAP32[(($6656)>>2)];
13306       var $6658=$st;
13307       var $6659=(($6658+4)|0);
13308       var $6660=$6659;
13309       var $6661=HEAP16[(($6660)>>1)];
13310       var $6662=(($6661)&65535);
13311       var $6663=(($6657+($6662<<2))|0);
13312       var $6664=$6663;
13313       var $6665=$6664;
13314       var $6666=HEAPF32[(($6665)>>2)];
13315       var $6667=($6654)-($6666);
13316       var $6668=$2;
13317       var $6669=(($6668+64)|0);
13318       var $6670=HEAP32[(($6669)>>2)];
13319       var $6671=$st;
13320       var $6672=(($6671+6)|0);
13321       var $6673=$6672;
13322       var $6674=HEAP16[(($6673)>>1)];
13323       var $6675=(($6674)&65535);
13324       var $6676=(($6670+($6675<<2))|0);
13325       var $6677=$6676;
13326       var $6678=$6677;
13327       HEAPF32[(($6678)>>2)]=$6667;
13328       __label__ = 366; break;
13329     case 263:
13330       var $6680=$2;
13331       var $6681=(($6680+64)|0);
13332       var $6682=HEAP32[(($6681)>>2)];
13333       var $6683=$st;
13334       var $6684=(($6683+2)|0);
13335       var $6685=$6684;
13336       var $6686=HEAP16[(($6685)>>1)];
13337       var $6687=(($6686)&65535);
13338       var $6688=(($6682+($6687<<2))|0);
13339       var $6689=$6688;
13340       var $6690=$6689;
13341       var $6691=(($6690)|0);
13342       var $6692=HEAPF32[(($6691)>>2)];
13343       var $6693=$2;
13344       var $6694=(($6693+64)|0);
13345       var $6695=HEAP32[(($6694)>>2)];
13346       var $6696=$st;
13347       var $6697=(($6696+4)|0);
13348       var $6698=$6697;
13349       var $6699=HEAP16[(($6698)>>1)];
13350       var $6700=(($6699)&65535);
13351       var $6701=(($6695+($6700<<2))|0);
13352       var $6702=$6701;
13353       var $6703=$6702;
13354       var $6704=(($6703)|0);
13355       var $6705=HEAPF32[(($6704)>>2)];
13356       var $6706=($6692)-($6705);
13357       var $6707=$2;
13358       var $6708=(($6707+64)|0);
13359       var $6709=HEAP32[(($6708)>>2)];
13360       var $6710=$st;
13361       var $6711=(($6710+6)|0);
13362       var $6712=$6711;
13363       var $6713=HEAP16[(($6712)>>1)];
13364       var $6714=(($6713)&65535);
13365       var $6715=(($6709+($6714<<2))|0);
13366       var $6716=$6715;
13367       var $6717=$6716;
13368       var $6718=(($6717)|0);
13369       HEAPF32[(($6718)>>2)]=$6706;
13370       var $6719=$2;
13371       var $6720=(($6719+64)|0);
13372       var $6721=HEAP32[(($6720)>>2)];
13373       var $6722=$st;
13374       var $6723=(($6722+2)|0);
13375       var $6724=$6723;
13376       var $6725=HEAP16[(($6724)>>1)];
13377       var $6726=(($6725)&65535);
13378       var $6727=(($6721+($6726<<2))|0);
13379       var $6728=$6727;
13380       var $6729=$6728;
13381       var $6730=(($6729+4)|0);
13382       var $6731=HEAPF32[(($6730)>>2)];
13383       var $6732=$2;
13384       var $6733=(($6732+64)|0);
13385       var $6734=HEAP32[(($6733)>>2)];
13386       var $6735=$st;
13387       var $6736=(($6735+4)|0);
13388       var $6737=$6736;
13389       var $6738=HEAP16[(($6737)>>1)];
13390       var $6739=(($6738)&65535);
13391       var $6740=(($6734+($6739<<2))|0);
13392       var $6741=$6740;
13393       var $6742=$6741;
13394       var $6743=(($6742+4)|0);
13395       var $6744=HEAPF32[(($6743)>>2)];
13396       var $6745=($6731)-($6744);
13397       var $6746=$2;
13398       var $6747=(($6746+64)|0);
13399       var $6748=HEAP32[(($6747)>>2)];
13400       var $6749=$st;
13401       var $6750=(($6749+6)|0);
13402       var $6751=$6750;
13403       var $6752=HEAP16[(($6751)>>1)];
13404       var $6753=(($6752)&65535);
13405       var $6754=(($6748+($6753<<2))|0);
13406       var $6755=$6754;
13407       var $6756=$6755;
13408       var $6757=(($6756+4)|0);
13409       HEAPF32[(($6757)>>2)]=$6745;
13410       var $6758=$2;
13411       var $6759=(($6758+64)|0);
13412       var $6760=HEAP32[(($6759)>>2)];
13413       var $6761=$st;
13414       var $6762=(($6761+2)|0);
13415       var $6763=$6762;
13416       var $6764=HEAP16[(($6763)>>1)];
13417       var $6765=(($6764)&65535);
13418       var $6766=(($6760+($6765<<2))|0);
13419       var $6767=$6766;
13420       var $6768=$6767;
13421       var $6769=(($6768+8)|0);
13422       var $6770=HEAPF32[(($6769)>>2)];
13423       var $6771=$2;
13424       var $6772=(($6771+64)|0);
13425       var $6773=HEAP32[(($6772)>>2)];
13426       var $6774=$st;
13427       var $6775=(($6774+4)|0);
13428       var $6776=$6775;
13429       var $6777=HEAP16[(($6776)>>1)];
13430       var $6778=(($6777)&65535);
13431       var $6779=(($6773+($6778<<2))|0);
13432       var $6780=$6779;
13433       var $6781=$6780;
13434       var $6782=(($6781+8)|0);
13435       var $6783=HEAPF32[(($6782)>>2)];
13436       var $6784=($6770)-($6783);
13437       var $6785=$2;
13438       var $6786=(($6785+64)|0);
13439       var $6787=HEAP32[(($6786)>>2)];
13440       var $6788=$st;
13441       var $6789=(($6788+6)|0);
13442       var $6790=$6789;
13443       var $6791=HEAP16[(($6790)>>1)];
13444       var $6792=(($6791)&65535);
13445       var $6793=(($6787+($6792<<2))|0);
13446       var $6794=$6793;
13447       var $6795=$6794;
13448       var $6796=(($6795+8)|0);
13449       HEAPF32[(($6796)>>2)]=$6784;
13450       __label__ = 366; break;
13451     case 264:
13452       var $6798=$2;
13453       var $6799=(($6798+64)|0);
13454       var $6800=HEAP32[(($6799)>>2)];
13455       var $6801=$st;
13456       var $6802=(($6801+2)|0);
13457       var $6803=$6802;
13458       var $6804=HEAP16[(($6803)>>1)];
13459       var $6805=(($6804)&65535);
13460       var $6806=(($6800+($6805<<2))|0);
13461       var $6807=$6806;
13462       var $6808=$6807;
13463       var $6809=HEAPF32[(($6808)>>2)];
13464       var $6810=$2;
13465       var $6811=(($6810+64)|0);
13466       var $6812=HEAP32[(($6811)>>2)];
13467       var $6813=$st;
13468       var $6814=(($6813+4)|0);
13469       var $6815=$6814;
13470       var $6816=HEAP16[(($6815)>>1)];
13471       var $6817=(($6816)&65535);
13472       var $6818=(($6812+($6817<<2))|0);
13473       var $6819=$6818;
13474       var $6820=$6819;
13475       var $6821=HEAPF32[(($6820)>>2)];
13476       var $6822=$6809 == $6821;
13477       var $6823=(($6822)&1);
13478       var $6824=(($6823)|0);
13479       var $6825=$2;
13480       var $6826=(($6825+64)|0);
13481       var $6827=HEAP32[(($6826)>>2)];
13482       var $6828=$st;
13483       var $6829=(($6828+6)|0);
13484       var $6830=$6829;
13485       var $6831=HEAP16[(($6830)>>1)];
13486       var $6832=(($6831)&65535);
13487       var $6833=(($6827+($6832<<2))|0);
13488       var $6834=$6833;
13489       var $6835=$6834;
13490       HEAPF32[(($6835)>>2)]=$6824;
13491       __label__ = 366; break;
13492     case 265:
13493       var $6837=$2;
13494       var $6838=(($6837+64)|0);
13495       var $6839=HEAP32[(($6838)>>2)];
13496       var $6840=$st;
13497       var $6841=(($6840+2)|0);
13498       var $6842=$6841;
13499       var $6843=HEAP16[(($6842)>>1)];
13500       var $6844=(($6843)&65535);
13501       var $6845=(($6839+($6844<<2))|0);
13502       var $6846=$6845;
13503       var $6847=$6846;
13504       var $6848=(($6847)|0);
13505       var $6849=HEAPF32[(($6848)>>2)];
13506       var $6850=$2;
13507       var $6851=(($6850+64)|0);
13508       var $6852=HEAP32[(($6851)>>2)];
13509       var $6853=$st;
13510       var $6854=(($6853+4)|0);
13511       var $6855=$6854;
13512       var $6856=HEAP16[(($6855)>>1)];
13513       var $6857=(($6856)&65535);
13514       var $6858=(($6852+($6857<<2))|0);
13515       var $6859=$6858;
13516       var $6860=$6859;
13517       var $6861=(($6860)|0);
13518       var $6862=HEAPF32[(($6861)>>2)];
13519       var $6863=$6849 == $6862;
13520       if ($6863) { __label__ = 266; break; } else { var $6921 = 0;__label__ = 268; break; }
13521     case 266:
13522       var $6865=$2;
13523       var $6866=(($6865+64)|0);
13524       var $6867=HEAP32[(($6866)>>2)];
13525       var $6868=$st;
13526       var $6869=(($6868+2)|0);
13527       var $6870=$6869;
13528       var $6871=HEAP16[(($6870)>>1)];
13529       var $6872=(($6871)&65535);
13530       var $6873=(($6867+($6872<<2))|0);
13531       var $6874=$6873;
13532       var $6875=$6874;
13533       var $6876=(($6875+4)|0);
13534       var $6877=HEAPF32[(($6876)>>2)];
13535       var $6878=$2;
13536       var $6879=(($6878+64)|0);
13537       var $6880=HEAP32[(($6879)>>2)];
13538       var $6881=$st;
13539       var $6882=(($6881+4)|0);
13540       var $6883=$6882;
13541       var $6884=HEAP16[(($6883)>>1)];
13542       var $6885=(($6884)&65535);
13543       var $6886=(($6880+($6885<<2))|0);
13544       var $6887=$6886;
13545       var $6888=$6887;
13546       var $6889=(($6888+4)|0);
13547       var $6890=HEAPF32[(($6889)>>2)];
13548       var $6891=$6877 == $6890;
13549       if ($6891) { __label__ = 267; break; } else { var $6921 = 0;__label__ = 268; break; }
13550     case 267:
13551       var $6893=$2;
13552       var $6894=(($6893+64)|0);
13553       var $6895=HEAP32[(($6894)>>2)];
13554       var $6896=$st;
13555       var $6897=(($6896+2)|0);
13556       var $6898=$6897;
13557       var $6899=HEAP16[(($6898)>>1)];
13558       var $6900=(($6899)&65535);
13559       var $6901=(($6895+($6900<<2))|0);
13560       var $6902=$6901;
13561       var $6903=$6902;
13562       var $6904=(($6903+8)|0);
13563       var $6905=HEAPF32[(($6904)>>2)];
13564       var $6906=$2;
13565       var $6907=(($6906+64)|0);
13566       var $6908=HEAP32[(($6907)>>2)];
13567       var $6909=$st;
13568       var $6910=(($6909+4)|0);
13569       var $6911=$6910;
13570       var $6912=HEAP16[(($6911)>>1)];
13571       var $6913=(($6912)&65535);
13572       var $6914=(($6908+($6913<<2))|0);
13573       var $6915=$6914;
13574       var $6916=$6915;
13575       var $6917=(($6916+8)|0);
13576       var $6918=HEAPF32[(($6917)>>2)];
13577       var $6919=$6905 == $6918;
13578       var $6921 = $6919;__label__ = 268; break;
13579     case 268:
13580       var $6921;
13581       var $6922=(($6921)&1);
13582       var $6923=(($6922)|0);
13583       var $6924=$2;
13584       var $6925=(($6924+64)|0);
13585       var $6926=HEAP32[(($6925)>>2)];
13586       var $6927=$st;
13587       var $6928=(($6927+6)|0);
13588       var $6929=$6928;
13589       var $6930=HEAP16[(($6929)>>1)];
13590       var $6931=(($6930)&65535);
13591       var $6932=(($6926+($6931<<2))|0);
13592       var $6933=$6932;
13593       var $6934=$6933;
13594       HEAPF32[(($6934)>>2)]=$6923;
13595       __label__ = 366; break;
13596     case 269:
13597       var $6936=$2;
13598       var $6937=$2;
13599       var $6938=(($6937+64)|0);
13600       var $6939=HEAP32[(($6938)>>2)];
13601       var $6940=$st;
13602       var $6941=(($6940+2)|0);
13603       var $6942=$6941;
13604       var $6943=HEAP16[(($6942)>>1)];
13605       var $6944=(($6943)&65535);
13606       var $6945=(($6939+($6944<<2))|0);
13607       var $6946=$6945;
13608       var $6947=$6946;
13609       var $6948=HEAP32[(($6947)>>2)];
13610       var $6949=_prog_getstring($6936, $6948);
13611       var $6950=$2;
13612       var $6951=$2;
13613       var $6952=(($6951+64)|0);
13614       var $6953=HEAP32[(($6952)>>2)];
13615       var $6954=$st;
13616       var $6955=(($6954+4)|0);
13617       var $6956=$6955;
13618       var $6957=HEAP16[(($6956)>>1)];
13619       var $6958=(($6957)&65535);
13620       var $6959=(($6953+($6958<<2))|0);
13621       var $6960=$6959;
13622       var $6961=$6960;
13623       var $6962=HEAP32[(($6961)>>2)];
13624       var $6963=_prog_getstring($6950, $6962);
13625       var $6964=_strcmp($6949, $6963);
13626       var $6965=(($6964)|0)!=0;
13627       var $6966=$6965 ^ 1;
13628       var $6967=(($6966)&1);
13629       var $6968=(($6967)|0);
13630       var $6969=$2;
13631       var $6970=(($6969+64)|0);
13632       var $6971=HEAP32[(($6970)>>2)];
13633       var $6972=$st;
13634       var $6973=(($6972+6)|0);
13635       var $6974=$6973;
13636       var $6975=HEAP16[(($6974)>>1)];
13637       var $6976=(($6975)&65535);
13638       var $6977=(($6971+($6976<<2))|0);
13639       var $6978=$6977;
13640       var $6979=$6978;
13641       HEAPF32[(($6979)>>2)]=$6968;
13642       __label__ = 366; break;
13643     case 270:
13644       var $6981=$2;
13645       var $6982=(($6981+64)|0);
13646       var $6983=HEAP32[(($6982)>>2)];
13647       var $6984=$st;
13648       var $6985=(($6984+2)|0);
13649       var $6986=$6985;
13650       var $6987=HEAP16[(($6986)>>1)];
13651       var $6988=(($6987)&65535);
13652       var $6989=(($6983+($6988<<2))|0);
13653       var $6990=$6989;
13654       var $6991=$6990;
13655       var $6992=HEAP32[(($6991)>>2)];
13656       var $6993=$2;
13657       var $6994=(($6993+64)|0);
13658       var $6995=HEAP32[(($6994)>>2)];
13659       var $6996=$st;
13660       var $6997=(($6996+4)|0);
13661       var $6998=$6997;
13662       var $6999=HEAP16[(($6998)>>1)];
13663       var $7000=(($6999)&65535);
13664       var $7001=(($6995+($7000<<2))|0);
13665       var $7002=$7001;
13666       var $7003=$7002;
13667       var $7004=HEAP32[(($7003)>>2)];
13668       var $7005=(($6992)|0)==(($7004)|0);
13669       var $7006=(($7005)&1);
13670       var $7007=(($7006)|0);
13671       var $7008=$2;
13672       var $7009=(($7008+64)|0);
13673       var $7010=HEAP32[(($7009)>>2)];
13674       var $7011=$st;
13675       var $7012=(($7011+6)|0);
13676       var $7013=$7012;
13677       var $7014=HEAP16[(($7013)>>1)];
13678       var $7015=(($7014)&65535);
13679       var $7016=(($7010+($7015<<2))|0);
13680       var $7017=$7016;
13681       var $7018=$7017;
13682       HEAPF32[(($7018)>>2)]=$7007;
13683       __label__ = 366; break;
13684     case 271:
13685       var $7020=$2;
13686       var $7021=(($7020+64)|0);
13687       var $7022=HEAP32[(($7021)>>2)];
13688       var $7023=$st;
13689       var $7024=(($7023+2)|0);
13690       var $7025=$7024;
13691       var $7026=HEAP16[(($7025)>>1)];
13692       var $7027=(($7026)&65535);
13693       var $7028=(($7022+($7027<<2))|0);
13694       var $7029=$7028;
13695       var $7030=$7029;
13696       var $7031=HEAP32[(($7030)>>2)];
13697       var $7032=$2;
13698       var $7033=(($7032+64)|0);
13699       var $7034=HEAP32[(($7033)>>2)];
13700       var $7035=$st;
13701       var $7036=(($7035+4)|0);
13702       var $7037=$7036;
13703       var $7038=HEAP16[(($7037)>>1)];
13704       var $7039=(($7038)&65535);
13705       var $7040=(($7034+($7039<<2))|0);
13706       var $7041=$7040;
13707       var $7042=$7041;
13708       var $7043=HEAP32[(($7042)>>2)];
13709       var $7044=(($7031)|0)==(($7043)|0);
13710       var $7045=(($7044)&1);
13711       var $7046=(($7045)|0);
13712       var $7047=$2;
13713       var $7048=(($7047+64)|0);
13714       var $7049=HEAP32[(($7048)>>2)];
13715       var $7050=$st;
13716       var $7051=(($7050+6)|0);
13717       var $7052=$7051;
13718       var $7053=HEAP16[(($7052)>>1)];
13719       var $7054=(($7053)&65535);
13720       var $7055=(($7049+($7054<<2))|0);
13721       var $7056=$7055;
13722       var $7057=$7056;
13723       HEAPF32[(($7057)>>2)]=$7046;
13724       __label__ = 366; break;
13725     case 272:
13726       var $7059=$2;
13727       var $7060=(($7059+64)|0);
13728       var $7061=HEAP32[(($7060)>>2)];
13729       var $7062=$st;
13730       var $7063=(($7062+2)|0);
13731       var $7064=$7063;
13732       var $7065=HEAP16[(($7064)>>1)];
13733       var $7066=(($7065)&65535);
13734       var $7067=(($7061+($7066<<2))|0);
13735       var $7068=$7067;
13736       var $7069=$7068;
13737       var $7070=HEAPF32[(($7069)>>2)];
13738       var $7071=$2;
13739       var $7072=(($7071+64)|0);
13740       var $7073=HEAP32[(($7072)>>2)];
13741       var $7074=$st;
13742       var $7075=(($7074+4)|0);
13743       var $7076=$7075;
13744       var $7077=HEAP16[(($7076)>>1)];
13745       var $7078=(($7077)&65535);
13746       var $7079=(($7073+($7078<<2))|0);
13747       var $7080=$7079;
13748       var $7081=$7080;
13749       var $7082=HEAPF32[(($7081)>>2)];
13750       var $7083=$7070 != $7082;
13751       var $7084=(($7083)&1);
13752       var $7085=(($7084)|0);
13753       var $7086=$2;
13754       var $7087=(($7086+64)|0);
13755       var $7088=HEAP32[(($7087)>>2)];
13756       var $7089=$st;
13757       var $7090=(($7089+6)|0);
13758       var $7091=$7090;
13759       var $7092=HEAP16[(($7091)>>1)];
13760       var $7093=(($7092)&65535);
13761       var $7094=(($7088+($7093<<2))|0);
13762       var $7095=$7094;
13763       var $7096=$7095;
13764       HEAPF32[(($7096)>>2)]=$7085;
13765       __label__ = 366; break;
13766     case 273:
13767       var $7098=$2;
13768       var $7099=(($7098+64)|0);
13769       var $7100=HEAP32[(($7099)>>2)];
13770       var $7101=$st;
13771       var $7102=(($7101+2)|0);
13772       var $7103=$7102;
13773       var $7104=HEAP16[(($7103)>>1)];
13774       var $7105=(($7104)&65535);
13775       var $7106=(($7100+($7105<<2))|0);
13776       var $7107=$7106;
13777       var $7108=$7107;
13778       var $7109=(($7108)|0);
13779       var $7110=HEAPF32[(($7109)>>2)];
13780       var $7111=$2;
13781       var $7112=(($7111+64)|0);
13782       var $7113=HEAP32[(($7112)>>2)];
13783       var $7114=$st;
13784       var $7115=(($7114+4)|0);
13785       var $7116=$7115;
13786       var $7117=HEAP16[(($7116)>>1)];
13787       var $7118=(($7117)&65535);
13788       var $7119=(($7113+($7118<<2))|0);
13789       var $7120=$7119;
13790       var $7121=$7120;
13791       var $7122=(($7121)|0);
13792       var $7123=HEAPF32[(($7122)>>2)];
13793       var $7124=$7110 != $7123;
13794       if ($7124) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 274; break; }
13795     case 274:
13796       var $7126=$2;
13797       var $7127=(($7126+64)|0);
13798       var $7128=HEAP32[(($7127)>>2)];
13799       var $7129=$st;
13800       var $7130=(($7129+2)|0);
13801       var $7131=$7130;
13802       var $7132=HEAP16[(($7131)>>1)];
13803       var $7133=(($7132)&65535);
13804       var $7134=(($7128+($7133<<2))|0);
13805       var $7135=$7134;
13806       var $7136=$7135;
13807       var $7137=(($7136+4)|0);
13808       var $7138=HEAPF32[(($7137)>>2)];
13809       var $7139=$2;
13810       var $7140=(($7139+64)|0);
13811       var $7141=HEAP32[(($7140)>>2)];
13812       var $7142=$st;
13813       var $7143=(($7142+4)|0);
13814       var $7144=$7143;
13815       var $7145=HEAP16[(($7144)>>1)];
13816       var $7146=(($7145)&65535);
13817       var $7147=(($7141+($7146<<2))|0);
13818       var $7148=$7147;
13819       var $7149=$7148;
13820       var $7150=(($7149+4)|0);
13821       var $7151=HEAPF32[(($7150)>>2)];
13822       var $7152=$7138 != $7151;
13823       if ($7152) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 275; break; }
13824     case 275:
13825       var $7154=$2;
13826       var $7155=(($7154+64)|0);
13827       var $7156=HEAP32[(($7155)>>2)];
13828       var $7157=$st;
13829       var $7158=(($7157+2)|0);
13830       var $7159=$7158;
13831       var $7160=HEAP16[(($7159)>>1)];
13832       var $7161=(($7160)&65535);
13833       var $7162=(($7156+($7161<<2))|0);
13834       var $7163=$7162;
13835       var $7164=$7163;
13836       var $7165=(($7164+8)|0);
13837       var $7166=HEAPF32[(($7165)>>2)];
13838       var $7167=$2;
13839       var $7168=(($7167+64)|0);
13840       var $7169=HEAP32[(($7168)>>2)];
13841       var $7170=$st;
13842       var $7171=(($7170+4)|0);
13843       var $7172=$7171;
13844       var $7173=HEAP16[(($7172)>>1)];
13845       var $7174=(($7173)&65535);
13846       var $7175=(($7169+($7174<<2))|0);
13847       var $7176=$7175;
13848       var $7177=$7176;
13849       var $7178=(($7177+8)|0);
13850       var $7179=HEAPF32[(($7178)>>2)];
13851       var $7180=$7166 != $7179;
13852       var $7182 = $7180;__label__ = 276; break;
13853     case 276:
13854       var $7182;
13855       var $7183=(($7182)&1);
13856       var $7184=(($7183)|0);
13857       var $7185=$2;
13858       var $7186=(($7185+64)|0);
13859       var $7187=HEAP32[(($7186)>>2)];
13860       var $7188=$st;
13861       var $7189=(($7188+6)|0);
13862       var $7190=$7189;
13863       var $7191=HEAP16[(($7190)>>1)];
13864       var $7192=(($7191)&65535);
13865       var $7193=(($7187+($7192<<2))|0);
13866       var $7194=$7193;
13867       var $7195=$7194;
13868       HEAPF32[(($7195)>>2)]=$7184;
13869       __label__ = 366; break;
13870     case 277:
13871       var $7197=$2;
13872       var $7198=$2;
13873       var $7199=(($7198+64)|0);
13874       var $7200=HEAP32[(($7199)>>2)];
13875       var $7201=$st;
13876       var $7202=(($7201+2)|0);
13877       var $7203=$7202;
13878       var $7204=HEAP16[(($7203)>>1)];
13879       var $7205=(($7204)&65535);
13880       var $7206=(($7200+($7205<<2))|0);
13881       var $7207=$7206;
13882       var $7208=$7207;
13883       var $7209=HEAP32[(($7208)>>2)];
13884       var $7210=_prog_getstring($7197, $7209);
13885       var $7211=$2;
13886       var $7212=$2;
13887       var $7213=(($7212+64)|0);
13888       var $7214=HEAP32[(($7213)>>2)];
13889       var $7215=$st;
13890       var $7216=(($7215+4)|0);
13891       var $7217=$7216;
13892       var $7218=HEAP16[(($7217)>>1)];
13893       var $7219=(($7218)&65535);
13894       var $7220=(($7214+($7219<<2))|0);
13895       var $7221=$7220;
13896       var $7222=$7221;
13897       var $7223=HEAP32[(($7222)>>2)];
13898       var $7224=_prog_getstring($7211, $7223);
13899       var $7225=_strcmp($7210, $7224);
13900       var $7226=(($7225)|0)!=0;
13901       var $7227=$7226 ^ 1;
13902       var $7228=$7227 ^ 1;
13903       var $7229=(($7228)&1);
13904       var $7230=(($7229)|0);
13905       var $7231=$2;
13906       var $7232=(($7231+64)|0);
13907       var $7233=HEAP32[(($7232)>>2)];
13908       var $7234=$st;
13909       var $7235=(($7234+6)|0);
13910       var $7236=$7235;
13911       var $7237=HEAP16[(($7236)>>1)];
13912       var $7238=(($7237)&65535);
13913       var $7239=(($7233+($7238<<2))|0);
13914       var $7240=$7239;
13915       var $7241=$7240;
13916       HEAPF32[(($7241)>>2)]=$7230;
13917       __label__ = 366; break;
13918     case 278:
13919       var $7243=$2;
13920       var $7244=(($7243+64)|0);
13921       var $7245=HEAP32[(($7244)>>2)];
13922       var $7246=$st;
13923       var $7247=(($7246+2)|0);
13924       var $7248=$7247;
13925       var $7249=HEAP16[(($7248)>>1)];
13926       var $7250=(($7249)&65535);
13927       var $7251=(($7245+($7250<<2))|0);
13928       var $7252=$7251;
13929       var $7253=$7252;
13930       var $7254=HEAP32[(($7253)>>2)];
13931       var $7255=$2;
13932       var $7256=(($7255+64)|0);
13933       var $7257=HEAP32[(($7256)>>2)];
13934       var $7258=$st;
13935       var $7259=(($7258+4)|0);
13936       var $7260=$7259;
13937       var $7261=HEAP16[(($7260)>>1)];
13938       var $7262=(($7261)&65535);
13939       var $7263=(($7257+($7262<<2))|0);
13940       var $7264=$7263;
13941       var $7265=$7264;
13942       var $7266=HEAP32[(($7265)>>2)];
13943       var $7267=(($7254)|0)!=(($7266)|0);
13944       var $7268=(($7267)&1);
13945       var $7269=(($7268)|0);
13946       var $7270=$2;
13947       var $7271=(($7270+64)|0);
13948       var $7272=HEAP32[(($7271)>>2)];
13949       var $7273=$st;
13950       var $7274=(($7273+6)|0);
13951       var $7275=$7274;
13952       var $7276=HEAP16[(($7275)>>1)];
13953       var $7277=(($7276)&65535);
13954       var $7278=(($7272+($7277<<2))|0);
13955       var $7279=$7278;
13956       var $7280=$7279;
13957       HEAPF32[(($7280)>>2)]=$7269;
13958       __label__ = 366; break;
13959     case 279:
13960       var $7282=$2;
13961       var $7283=(($7282+64)|0);
13962       var $7284=HEAP32[(($7283)>>2)];
13963       var $7285=$st;
13964       var $7286=(($7285+2)|0);
13965       var $7287=$7286;
13966       var $7288=HEAP16[(($7287)>>1)];
13967       var $7289=(($7288)&65535);
13968       var $7290=(($7284+($7289<<2))|0);
13969       var $7291=$7290;
13970       var $7292=$7291;
13971       var $7293=HEAP32[(($7292)>>2)];
13972       var $7294=$2;
13973       var $7295=(($7294+64)|0);
13974       var $7296=HEAP32[(($7295)>>2)];
13975       var $7297=$st;
13976       var $7298=(($7297+4)|0);
13977       var $7299=$7298;
13978       var $7300=HEAP16[(($7299)>>1)];
13979       var $7301=(($7300)&65535);
13980       var $7302=(($7296+($7301<<2))|0);
13981       var $7303=$7302;
13982       var $7304=$7303;
13983       var $7305=HEAP32[(($7304)>>2)];
13984       var $7306=(($7293)|0)!=(($7305)|0);
13985       var $7307=(($7306)&1);
13986       var $7308=(($7307)|0);
13987       var $7309=$2;
13988       var $7310=(($7309+64)|0);
13989       var $7311=HEAP32[(($7310)>>2)];
13990       var $7312=$st;
13991       var $7313=(($7312+6)|0);
13992       var $7314=$7313;
13993       var $7315=HEAP16[(($7314)>>1)];
13994       var $7316=(($7315)&65535);
13995       var $7317=(($7311+($7316<<2))|0);
13996       var $7318=$7317;
13997       var $7319=$7318;
13998       HEAPF32[(($7319)>>2)]=$7308;
13999       __label__ = 366; break;
14000     case 280:
14001       var $7321=$2;
14002       var $7322=(($7321+64)|0);
14003       var $7323=HEAP32[(($7322)>>2)];
14004       var $7324=$st;
14005       var $7325=(($7324+2)|0);
14006       var $7326=$7325;
14007       var $7327=HEAP16[(($7326)>>1)];
14008       var $7328=(($7327)&65535);
14009       var $7329=(($7323+($7328<<2))|0);
14010       var $7330=$7329;
14011       var $7331=$7330;
14012       var $7332=HEAPF32[(($7331)>>2)];
14013       var $7333=$2;
14014       var $7334=(($7333+64)|0);
14015       var $7335=HEAP32[(($7334)>>2)];
14016       var $7336=$st;
14017       var $7337=(($7336+4)|0);
14018       var $7338=$7337;
14019       var $7339=HEAP16[(($7338)>>1)];
14020       var $7340=(($7339)&65535);
14021       var $7341=(($7335+($7340<<2))|0);
14022       var $7342=$7341;
14023       var $7343=$7342;
14024       var $7344=HEAPF32[(($7343)>>2)];
14025       var $7345=$7332 <= $7344;
14026       var $7346=(($7345)&1);
14027       var $7347=(($7346)|0);
14028       var $7348=$2;
14029       var $7349=(($7348+64)|0);
14030       var $7350=HEAP32[(($7349)>>2)];
14031       var $7351=$st;
14032       var $7352=(($7351+6)|0);
14033       var $7353=$7352;
14034       var $7354=HEAP16[(($7353)>>1)];
14035       var $7355=(($7354)&65535);
14036       var $7356=(($7350+($7355<<2))|0);
14037       var $7357=$7356;
14038       var $7358=$7357;
14039       HEAPF32[(($7358)>>2)]=$7347;
14040       __label__ = 366; break;
14041     case 281:
14042       var $7360=$2;
14043       var $7361=(($7360+64)|0);
14044       var $7362=HEAP32[(($7361)>>2)];
14045       var $7363=$st;
14046       var $7364=(($7363+2)|0);
14047       var $7365=$7364;
14048       var $7366=HEAP16[(($7365)>>1)];
14049       var $7367=(($7366)&65535);
14050       var $7368=(($7362+($7367<<2))|0);
14051       var $7369=$7368;
14052       var $7370=$7369;
14053       var $7371=HEAPF32[(($7370)>>2)];
14054       var $7372=$2;
14055       var $7373=(($7372+64)|0);
14056       var $7374=HEAP32[(($7373)>>2)];
14057       var $7375=$st;
14058       var $7376=(($7375+4)|0);
14059       var $7377=$7376;
14060       var $7378=HEAP16[(($7377)>>1)];
14061       var $7379=(($7378)&65535);
14062       var $7380=(($7374+($7379<<2))|0);
14063       var $7381=$7380;
14064       var $7382=$7381;
14065       var $7383=HEAPF32[(($7382)>>2)];
14066       var $7384=$7371 >= $7383;
14067       var $7385=(($7384)&1);
14068       var $7386=(($7385)|0);
14069       var $7387=$2;
14070       var $7388=(($7387+64)|0);
14071       var $7389=HEAP32[(($7388)>>2)];
14072       var $7390=$st;
14073       var $7391=(($7390+6)|0);
14074       var $7392=$7391;
14075       var $7393=HEAP16[(($7392)>>1)];
14076       var $7394=(($7393)&65535);
14077       var $7395=(($7389+($7394<<2))|0);
14078       var $7396=$7395;
14079       var $7397=$7396;
14080       HEAPF32[(($7397)>>2)]=$7386;
14081       __label__ = 366; break;
14082     case 282:
14083       var $7399=$2;
14084       var $7400=(($7399+64)|0);
14085       var $7401=HEAP32[(($7400)>>2)];
14086       var $7402=$st;
14087       var $7403=(($7402+2)|0);
14088       var $7404=$7403;
14089       var $7405=HEAP16[(($7404)>>1)];
14090       var $7406=(($7405)&65535);
14091       var $7407=(($7401+($7406<<2))|0);
14092       var $7408=$7407;
14093       var $7409=$7408;
14094       var $7410=HEAPF32[(($7409)>>2)];
14095       var $7411=$2;
14096       var $7412=(($7411+64)|0);
14097       var $7413=HEAP32[(($7412)>>2)];
14098       var $7414=$st;
14099       var $7415=(($7414+4)|0);
14100       var $7416=$7415;
14101       var $7417=HEAP16[(($7416)>>1)];
14102       var $7418=(($7417)&65535);
14103       var $7419=(($7413+($7418<<2))|0);
14104       var $7420=$7419;
14105       var $7421=$7420;
14106       var $7422=HEAPF32[(($7421)>>2)];
14107       var $7423=$7410 < $7422;
14108       var $7424=(($7423)&1);
14109       var $7425=(($7424)|0);
14110       var $7426=$2;
14111       var $7427=(($7426+64)|0);
14112       var $7428=HEAP32[(($7427)>>2)];
14113       var $7429=$st;
14114       var $7430=(($7429+6)|0);
14115       var $7431=$7430;
14116       var $7432=HEAP16[(($7431)>>1)];
14117       var $7433=(($7432)&65535);
14118       var $7434=(($7428+($7433<<2))|0);
14119       var $7435=$7434;
14120       var $7436=$7435;
14121       HEAPF32[(($7436)>>2)]=$7425;
14122       __label__ = 366; break;
14123     case 283:
14124       var $7438=$2;
14125       var $7439=(($7438+64)|0);
14126       var $7440=HEAP32[(($7439)>>2)];
14127       var $7441=$st;
14128       var $7442=(($7441+2)|0);
14129       var $7443=$7442;
14130       var $7444=HEAP16[(($7443)>>1)];
14131       var $7445=(($7444)&65535);
14132       var $7446=(($7440+($7445<<2))|0);
14133       var $7447=$7446;
14134       var $7448=$7447;
14135       var $7449=HEAPF32[(($7448)>>2)];
14136       var $7450=$2;
14137       var $7451=(($7450+64)|0);
14138       var $7452=HEAP32[(($7451)>>2)];
14139       var $7453=$st;
14140       var $7454=(($7453+4)|0);
14141       var $7455=$7454;
14142       var $7456=HEAP16[(($7455)>>1)];
14143       var $7457=(($7456)&65535);
14144       var $7458=(($7452+($7457<<2))|0);
14145       var $7459=$7458;
14146       var $7460=$7459;
14147       var $7461=HEAPF32[(($7460)>>2)];
14148       var $7462=$7449 > $7461;
14149       var $7463=(($7462)&1);
14150       var $7464=(($7463)|0);
14151       var $7465=$2;
14152       var $7466=(($7465+64)|0);
14153       var $7467=HEAP32[(($7466)>>2)];
14154       var $7468=$st;
14155       var $7469=(($7468+6)|0);
14156       var $7470=$7469;
14157       var $7471=HEAP16[(($7470)>>1)];
14158       var $7472=(($7471)&65535);
14159       var $7473=(($7467+($7472<<2))|0);
14160       var $7474=$7473;
14161       var $7475=$7474;
14162       HEAPF32[(($7475)>>2)]=$7464;
14163       __label__ = 366; break;
14164     case 284:
14165       var $7477=$2;
14166       var $7478=(($7477+64)|0);
14167       var $7479=HEAP32[(($7478)>>2)];
14168       var $7480=$st;
14169       var $7481=(($7480+2)|0);
14170       var $7482=$7481;
14171       var $7483=HEAP16[(($7482)>>1)];
14172       var $7484=(($7483)&65535);
14173       var $7485=(($7479+($7484<<2))|0);
14174       var $7486=$7485;
14175       var $7487=$7486;
14176       var $7488=HEAP32[(($7487)>>2)];
14177       var $7489=(($7488)|0) < 0;
14178       if ($7489) { __label__ = 286; break; } else { __label__ = 285; break; }
14179     case 285:
14180       var $7491=$2;
14181       var $7492=(($7491+64)|0);
14182       var $7493=HEAP32[(($7492)>>2)];
14183       var $7494=$st;
14184       var $7495=(($7494+2)|0);
14185       var $7496=$7495;
14186       var $7497=HEAP16[(($7496)>>1)];
14187       var $7498=(($7497)&65535);
14188       var $7499=(($7493+($7498<<2))|0);
14189       var $7500=$7499;
14190       var $7501=$7500;
14191       var $7502=HEAP32[(($7501)>>2)];
14192       var $7503=$2;
14193       var $7504=(($7503+140)|0);
14194       var $7505=HEAP32[(($7504)>>2)];
14195       var $7506=(($7502)|0) >= (($7505)|0);
14196       if ($7506) { __label__ = 286; break; } else { __label__ = 287; break; }
14197     case 286:
14198       var $7508=$2;
14199       var $7509=$2;
14200       var $7510=(($7509)|0);
14201       var $7511=HEAP32[(($7510)>>2)];
14202       _qcvmerror($7508, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7511,tempInt));
14203       __label__ = 488; break;
14204     case 287:
14205       var $7513=$2;
14206       var $7514=(($7513+64)|0);
14207       var $7515=HEAP32[(($7514)>>2)];
14208       var $7516=$st;
14209       var $7517=(($7516+4)|0);
14210       var $7518=$7517;
14211       var $7519=HEAP16[(($7518)>>1)];
14212       var $7520=(($7519)&65535);
14213       var $7521=(($7515+($7520<<2))|0);
14214       var $7522=$7521;
14215       var $7523=$7522;
14216       var $7524=HEAP32[(($7523)>>2)];
14217       var $7525=$2;
14218       var $7526=(($7525+144)|0);
14219       var $7527=HEAP32[(($7526)>>2)];
14220       var $7528=(($7524)>>>0) >= (($7527)>>>0);
14221       if ($7528) { __label__ = 288; break; } else { __label__ = 289; break; }
14222     case 288:
14223       var $7530=$2;
14224       var $7531=$2;
14225       var $7532=(($7531)|0);
14226       var $7533=HEAP32[(($7532)>>2)];
14227       var $7534=$2;
14228       var $7535=(($7534+64)|0);
14229       var $7536=HEAP32[(($7535)>>2)];
14230       var $7537=$st;
14231       var $7538=(($7537+4)|0);
14232       var $7539=$7538;
14233       var $7540=HEAP16[(($7539)>>1)];
14234       var $7541=(($7540)&65535);
14235       var $7542=(($7536+($7541<<2))|0);
14236       var $7543=$7542;
14237       var $7544=$7543;
14238       var $7545=HEAP32[(($7544)>>2)];
14239       _qcvmerror($7530, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7533,HEAP32[(((tempInt)+(4))>>2)]=$7545,tempInt));
14240       __label__ = 488; break;
14241     case 289:
14242       var $7547=$2;
14243       var $7548=$2;
14244       var $7549=(($7548+64)|0);
14245       var $7550=HEAP32[(($7549)>>2)];
14246       var $7551=$st;
14247       var $7552=(($7551+2)|0);
14248       var $7553=$7552;
14249       var $7554=HEAP16[(($7553)>>1)];
14250       var $7555=(($7554)&65535);
14251       var $7556=(($7550+($7555<<2))|0);
14252       var $7557=$7556;
14253       var $7558=$7557;
14254       var $7559=HEAP32[(($7558)>>2)];
14255       var $7560=_prog_getedict($7547, $7559);
14256       $ed6=$7560;
14257       var $7561=$ed6;
14258       var $7562=$7561;
14259       var $7563=$2;
14260       var $7564=(($7563+64)|0);
14261       var $7565=HEAP32[(($7564)>>2)];
14262       var $7566=$st;
14263       var $7567=(($7566+4)|0);
14264       var $7568=$7567;
14265       var $7569=HEAP16[(($7568)>>1)];
14266       var $7570=(($7569)&65535);
14267       var $7571=(($7565+($7570<<2))|0);
14268       var $7572=$7571;
14269       var $7573=$7572;
14270       var $7574=HEAP32[(($7573)>>2)];
14271       var $7575=(($7562+($7574<<2))|0);
14272       var $7576=$7575;
14273       var $7577=$7576;
14274       var $7578=HEAP32[(($7577)>>2)];
14275       var $7579=$2;
14276       var $7580=(($7579+64)|0);
14277       var $7581=HEAP32[(($7580)>>2)];
14278       var $7582=$st;
14279       var $7583=(($7582+6)|0);
14280       var $7584=$7583;
14281       var $7585=HEAP16[(($7584)>>1)];
14282       var $7586=(($7585)&65535);
14283       var $7587=(($7581+($7586<<2))|0);
14284       var $7588=$7587;
14285       var $7589=$7588;
14286       HEAP32[(($7589)>>2)]=$7578;
14287       __label__ = 366; break;
14288     case 290:
14289       var $7591=$2;
14290       var $7592=(($7591+64)|0);
14291       var $7593=HEAP32[(($7592)>>2)];
14292       var $7594=$st;
14293       var $7595=(($7594+2)|0);
14294       var $7596=$7595;
14295       var $7597=HEAP16[(($7596)>>1)];
14296       var $7598=(($7597)&65535);
14297       var $7599=(($7593+($7598<<2))|0);
14298       var $7600=$7599;
14299       var $7601=$7600;
14300       var $7602=HEAP32[(($7601)>>2)];
14301       var $7603=(($7602)|0) < 0;
14302       if ($7603) { __label__ = 292; break; } else { __label__ = 291; break; }
14303     case 291:
14304       var $7605=$2;
14305       var $7606=(($7605+64)|0);
14306       var $7607=HEAP32[(($7606)>>2)];
14307       var $7608=$st;
14308       var $7609=(($7608+2)|0);
14309       var $7610=$7609;
14310       var $7611=HEAP16[(($7610)>>1)];
14311       var $7612=(($7611)&65535);
14312       var $7613=(($7607+($7612<<2))|0);
14313       var $7614=$7613;
14314       var $7615=$7614;
14315       var $7616=HEAP32[(($7615)>>2)];
14316       var $7617=$2;
14317       var $7618=(($7617+140)|0);
14318       var $7619=HEAP32[(($7618)>>2)];
14319       var $7620=(($7616)|0) >= (($7619)|0);
14320       if ($7620) { __label__ = 292; break; } else { __label__ = 293; break; }
14321     case 292:
14322       var $7622=$2;
14323       var $7623=$2;
14324       var $7624=(($7623)|0);
14325       var $7625=HEAP32[(($7624)>>2)];
14326       _qcvmerror($7622, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7625,tempInt));
14327       __label__ = 488; break;
14328     case 293:
14329       var $7627=$2;
14330       var $7628=(($7627+64)|0);
14331       var $7629=HEAP32[(($7628)>>2)];
14332       var $7630=$st;
14333       var $7631=(($7630+4)|0);
14334       var $7632=$7631;
14335       var $7633=HEAP16[(($7632)>>1)];
14336       var $7634=(($7633)&65535);
14337       var $7635=(($7629+($7634<<2))|0);
14338       var $7636=$7635;
14339       var $7637=$7636;
14340       var $7638=HEAP32[(($7637)>>2)];
14341       var $7639=(($7638)|0) < 0;
14342       if ($7639) { __label__ = 295; break; } else { __label__ = 294; break; }
14343     case 294:
14344       var $7641=$2;
14345       var $7642=(($7641+64)|0);
14346       var $7643=HEAP32[(($7642)>>2)];
14347       var $7644=$st;
14348       var $7645=(($7644+4)|0);
14349       var $7646=$7645;
14350       var $7647=HEAP16[(($7646)>>1)];
14351       var $7648=(($7647)&65535);
14352       var $7649=(($7643+($7648<<2))|0);
14353       var $7650=$7649;
14354       var $7651=$7650;
14355       var $7652=HEAP32[(($7651)>>2)];
14356       var $7653=((($7652)+(3))|0);
14357       var $7654=$2;
14358       var $7655=(($7654+144)|0);
14359       var $7656=HEAP32[(($7655)>>2)];
14360       var $7657=(($7653)>>>0) > (($7656)>>>0);
14361       if ($7657) { __label__ = 295; break; } else { __label__ = 296; break; }
14362     case 295:
14363       var $7659=$2;
14364       var $7660=$2;
14365       var $7661=(($7660)|0);
14366       var $7662=HEAP32[(($7661)>>2)];
14367       var $7663=$2;
14368       var $7664=(($7663+64)|0);
14369       var $7665=HEAP32[(($7664)>>2)];
14370       var $7666=$st;
14371       var $7667=(($7666+4)|0);
14372       var $7668=$7667;
14373       var $7669=HEAP16[(($7668)>>1)];
14374       var $7670=(($7669)&65535);
14375       var $7671=(($7665+($7670<<2))|0);
14376       var $7672=$7671;
14377       var $7673=$7672;
14378       var $7674=HEAP32[(($7673)>>2)];
14379       var $7675=((($7674)+(2))|0);
14380       _qcvmerror($7659, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7662,HEAP32[(((tempInt)+(4))>>2)]=$7675,tempInt));
14381       __label__ = 488; break;
14382     case 296:
14383       var $7677=$2;
14384       var $7678=$2;
14385       var $7679=(($7678+64)|0);
14386       var $7680=HEAP32[(($7679)>>2)];
14387       var $7681=$st;
14388       var $7682=(($7681+2)|0);
14389       var $7683=$7682;
14390       var $7684=HEAP16[(($7683)>>1)];
14391       var $7685=(($7684)&65535);
14392       var $7686=(($7680+($7685<<2))|0);
14393       var $7687=$7686;
14394       var $7688=$7687;
14395       var $7689=HEAP32[(($7688)>>2)];
14396       var $7690=_prog_getedict($7677, $7689);
14397       $ed6=$7690;
14398       var $7691=$ed6;
14399       var $7692=$7691;
14400       var $7693=$2;
14401       var $7694=(($7693+64)|0);
14402       var $7695=HEAP32[(($7694)>>2)];
14403       var $7696=$st;
14404       var $7697=(($7696+4)|0);
14405       var $7698=$7697;
14406       var $7699=HEAP16[(($7698)>>1)];
14407       var $7700=(($7699)&65535);
14408       var $7701=(($7695+($7700<<2))|0);
14409       var $7702=$7701;
14410       var $7703=$7702;
14411       var $7704=HEAP32[(($7703)>>2)];
14412       var $7705=(($7692+($7704<<2))|0);
14413       var $7706=$7705;
14414       var $7707=$7706;
14415       var $7708=(($7707)|0);
14416       var $7709=HEAP32[(($7708)>>2)];
14417       var $7710=$2;
14418       var $7711=(($7710+64)|0);
14419       var $7712=HEAP32[(($7711)>>2)];
14420       var $7713=$st;
14421       var $7714=(($7713+6)|0);
14422       var $7715=$7714;
14423       var $7716=HEAP16[(($7715)>>1)];
14424       var $7717=(($7716)&65535);
14425       var $7718=(($7712+($7717<<2))|0);
14426       var $7719=$7718;
14427       var $7720=$7719;
14428       var $7721=(($7720)|0);
14429       HEAP32[(($7721)>>2)]=$7709;
14430       var $7722=$ed6;
14431       var $7723=$7722;
14432       var $7724=$2;
14433       var $7725=(($7724+64)|0);
14434       var $7726=HEAP32[(($7725)>>2)];
14435       var $7727=$st;
14436       var $7728=(($7727+4)|0);
14437       var $7729=$7728;
14438       var $7730=HEAP16[(($7729)>>1)];
14439       var $7731=(($7730)&65535);
14440       var $7732=(($7726+($7731<<2))|0);
14441       var $7733=$7732;
14442       var $7734=$7733;
14443       var $7735=HEAP32[(($7734)>>2)];
14444       var $7736=(($7723+($7735<<2))|0);
14445       var $7737=$7736;
14446       var $7738=$7737;
14447       var $7739=(($7738+4)|0);
14448       var $7740=HEAP32[(($7739)>>2)];
14449       var $7741=$2;
14450       var $7742=(($7741+64)|0);
14451       var $7743=HEAP32[(($7742)>>2)];
14452       var $7744=$st;
14453       var $7745=(($7744+6)|0);
14454       var $7746=$7745;
14455       var $7747=HEAP16[(($7746)>>1)];
14456       var $7748=(($7747)&65535);
14457       var $7749=(($7743+($7748<<2))|0);
14458       var $7750=$7749;
14459       var $7751=$7750;
14460       var $7752=(($7751+4)|0);
14461       HEAP32[(($7752)>>2)]=$7740;
14462       var $7753=$ed6;
14463       var $7754=$7753;
14464       var $7755=$2;
14465       var $7756=(($7755+64)|0);
14466       var $7757=HEAP32[(($7756)>>2)];
14467       var $7758=$st;
14468       var $7759=(($7758+4)|0);
14469       var $7760=$7759;
14470       var $7761=HEAP16[(($7760)>>1)];
14471       var $7762=(($7761)&65535);
14472       var $7763=(($7757+($7762<<2))|0);
14473       var $7764=$7763;
14474       var $7765=$7764;
14475       var $7766=HEAP32[(($7765)>>2)];
14476       var $7767=(($7754+($7766<<2))|0);
14477       var $7768=$7767;
14478       var $7769=$7768;
14479       var $7770=(($7769+8)|0);
14480       var $7771=HEAP32[(($7770)>>2)];
14481       var $7772=$2;
14482       var $7773=(($7772+64)|0);
14483       var $7774=HEAP32[(($7773)>>2)];
14484       var $7775=$st;
14485       var $7776=(($7775+6)|0);
14486       var $7777=$7776;
14487       var $7778=HEAP16[(($7777)>>1)];
14488       var $7779=(($7778)&65535);
14489       var $7780=(($7774+($7779<<2))|0);
14490       var $7781=$7780;
14491       var $7782=$7781;
14492       var $7783=(($7782+8)|0);
14493       HEAP32[(($7783)>>2)]=$7771;
14494       __label__ = 366; break;
14495     case 297:
14496       var $7785=$2;
14497       var $7786=(($7785+64)|0);
14498       var $7787=HEAP32[(($7786)>>2)];
14499       var $7788=$st;
14500       var $7789=(($7788+2)|0);
14501       var $7790=$7789;
14502       var $7791=HEAP16[(($7790)>>1)];
14503       var $7792=(($7791)&65535);
14504       var $7793=(($7787+($7792<<2))|0);
14505       var $7794=$7793;
14506       var $7795=$7794;
14507       var $7796=HEAP32[(($7795)>>2)];
14508       var $7797=(($7796)|0) < 0;
14509       if ($7797) { __label__ = 299; break; } else { __label__ = 298; break; }
14510     case 298:
14511       var $7799=$2;
14512       var $7800=(($7799+64)|0);
14513       var $7801=HEAP32[(($7800)>>2)];
14514       var $7802=$st;
14515       var $7803=(($7802+2)|0);
14516       var $7804=$7803;
14517       var $7805=HEAP16[(($7804)>>1)];
14518       var $7806=(($7805)&65535);
14519       var $7807=(($7801+($7806<<2))|0);
14520       var $7808=$7807;
14521       var $7809=$7808;
14522       var $7810=HEAP32[(($7809)>>2)];
14523       var $7811=$2;
14524       var $7812=(($7811+140)|0);
14525       var $7813=HEAP32[(($7812)>>2)];
14526       var $7814=(($7810)|0) >= (($7813)|0);
14527       if ($7814) { __label__ = 299; break; } else { __label__ = 300; break; }
14528     case 299:
14529       var $7816=$2;
14530       var $7817=$2;
14531       var $7818=(($7817)|0);
14532       var $7819=HEAP32[(($7818)>>2)];
14533       var $7820=$2;
14534       var $7821=(($7820+64)|0);
14535       var $7822=HEAP32[(($7821)>>2)];
14536       var $7823=$st;
14537       var $7824=(($7823+2)|0);
14538       var $7825=$7824;
14539       var $7826=HEAP16[(($7825)>>1)];
14540       var $7827=(($7826)&65535);
14541       var $7828=(($7822+($7827<<2))|0);
14542       var $7829=$7828;
14543       var $7830=$7829;
14544       var $7831=HEAP32[(($7830)>>2)];
14545       _qcvmerror($7816, ((STRING_TABLE.__str19)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7819,HEAP32[(((tempInt)+(4))>>2)]=$7831,tempInt));
14546       __label__ = 488; break;
14547     case 300:
14548       var $7833=$2;
14549       var $7834=(($7833+64)|0);
14550       var $7835=HEAP32[(($7834)>>2)];
14551       var $7836=$st;
14552       var $7837=(($7836+4)|0);
14553       var $7838=$7837;
14554       var $7839=HEAP16[(($7838)>>1)];
14555       var $7840=(($7839)&65535);
14556       var $7841=(($7835+($7840<<2))|0);
14557       var $7842=$7841;
14558       var $7843=$7842;
14559       var $7844=HEAP32[(($7843)>>2)];
14560       var $7845=$2;
14561       var $7846=(($7845+144)|0);
14562       var $7847=HEAP32[(($7846)>>2)];
14563       var $7848=(($7844)>>>0) >= (($7847)>>>0);
14564       if ($7848) { __label__ = 301; break; } else { __label__ = 302; break; }
14565     case 301:
14566       var $7850=$2;
14567       var $7851=$2;
14568       var $7852=(($7851)|0);
14569       var $7853=HEAP32[(($7852)>>2)];
14570       var $7854=$2;
14571       var $7855=(($7854+64)|0);
14572       var $7856=HEAP32[(($7855)>>2)];
14573       var $7857=$st;
14574       var $7858=(($7857+4)|0);
14575       var $7859=$7858;
14576       var $7860=HEAP16[(($7859)>>1)];
14577       var $7861=(($7860)&65535);
14578       var $7862=(($7856+($7861<<2))|0);
14579       var $7863=$7862;
14580       var $7864=$7863;
14581       var $7865=HEAP32[(($7864)>>2)];
14582       _qcvmerror($7850, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$7853,HEAP32[(((tempInt)+(4))>>2)]=$7865,tempInt));
14583       __label__ = 488; break;
14584     case 302:
14585       var $7867=$2;
14586       var $7868=$2;
14587       var $7869=(($7868+64)|0);
14588       var $7870=HEAP32[(($7869)>>2)];
14589       var $7871=$st;
14590       var $7872=(($7871+2)|0);
14591       var $7873=$7872;
14592       var $7874=HEAP16[(($7873)>>1)];
14593       var $7875=(($7874)&65535);
14594       var $7876=(($7870+($7875<<2))|0);
14595       var $7877=$7876;
14596       var $7878=$7877;
14597       var $7879=HEAP32[(($7878)>>2)];
14598       var $7880=_prog_getedict($7867, $7879);
14599       $ed6=$7880;
14600       var $7881=$ed6;
14601       var $7882=$7881;
14602       var $7883=$2;
14603       var $7884=(($7883+76)|0);
14604       var $7885=HEAP32[(($7884)>>2)];
14605       var $7886=$7882;
14606       var $7887=$7885;
14607       var $7888=((($7886)-($7887))|0);
14608       var $7889=((((($7888)|0))/(4))&-1);
14609       var $7890=$2;
14610       var $7891=(($7890+64)|0);
14611       var $7892=HEAP32[(($7891)>>2)];
14612       var $7893=$st;
14613       var $7894=(($7893+6)|0);
14614       var $7895=$7894;
14615       var $7896=HEAP16[(($7895)>>1)];
14616       var $7897=(($7896)&65535);
14617       var $7898=(($7892+($7897<<2))|0);
14618       var $7899=$7898;
14619       var $7900=$7899;
14620       HEAP32[(($7900)>>2)]=$7889;
14621       var $7901=$2;
14622       var $7902=(($7901+64)|0);
14623       var $7903=HEAP32[(($7902)>>2)];
14624       var $7904=$st;
14625       var $7905=(($7904+4)|0);
14626       var $7906=$7905;
14627       var $7907=HEAP16[(($7906)>>1)];
14628       var $7908=(($7907)&65535);
14629       var $7909=(($7903+($7908<<2))|0);
14630       var $7910=$7909;
14631       var $7911=$7910;
14632       var $7912=HEAP32[(($7911)>>2)];
14633       var $7913=$2;
14634       var $7914=(($7913+64)|0);
14635       var $7915=HEAP32[(($7914)>>2)];
14636       var $7916=$st;
14637       var $7917=(($7916+6)|0);
14638       var $7918=$7917;
14639       var $7919=HEAP16[(($7918)>>1)];
14640       var $7920=(($7919)&65535);
14641       var $7921=(($7915+($7920<<2))|0);
14642       var $7922=$7921;
14643       var $7923=$7922;
14644       var $7924=HEAP32[(($7923)>>2)];
14645       var $7925=((($7924)+($7912))|0);
14646       HEAP32[(($7923)>>2)]=$7925;
14647       __label__ = 366; break;
14648     case 303:
14649       var $7927=$2;
14650       var $7928=(($7927+64)|0);
14651       var $7929=HEAP32[(($7928)>>2)];
14652       var $7930=$st;
14653       var $7931=(($7930+2)|0);
14654       var $7932=$7931;
14655       var $7933=HEAP16[(($7932)>>1)];
14656       var $7934=(($7933)&65535);
14657       var $7935=(($7929+($7934<<2))|0);
14658       var $7936=$7935;
14659       var $7937=$7936;
14660       var $7938=HEAP32[(($7937)>>2)];
14661       var $7939=$2;
14662       var $7940=(($7939+64)|0);
14663       var $7941=HEAP32[(($7940)>>2)];
14664       var $7942=$st;
14665       var $7943=(($7942+4)|0);
14666       var $7944=$7943;
14667       var $7945=HEAP16[(($7944)>>1)];
14668       var $7946=(($7945)&65535);
14669       var $7947=(($7941+($7946<<2))|0);
14670       var $7948=$7947;
14671       var $7949=$7948;
14672       HEAP32[(($7949)>>2)]=$7938;
14673       __label__ = 366; break;
14674     case 304:
14675       var $7951=$2;
14676       var $7952=(($7951+64)|0);
14677       var $7953=HEAP32[(($7952)>>2)];
14678       var $7954=$st;
14679       var $7955=(($7954+2)|0);
14680       var $7956=$7955;
14681       var $7957=HEAP16[(($7956)>>1)];
14682       var $7958=(($7957)&65535);
14683       var $7959=(($7953+($7958<<2))|0);
14684       var $7960=$7959;
14685       var $7961=$7960;
14686       var $7962=(($7961)|0);
14687       var $7963=HEAP32[(($7962)>>2)];
14688       var $7964=$2;
14689       var $7965=(($7964+64)|0);
14690       var $7966=HEAP32[(($7965)>>2)];
14691       var $7967=$st;
14692       var $7968=(($7967+4)|0);
14693       var $7969=$7968;
14694       var $7970=HEAP16[(($7969)>>1)];
14695       var $7971=(($7970)&65535);
14696       var $7972=(($7966+($7971<<2))|0);
14697       var $7973=$7972;
14698       var $7974=$7973;
14699       var $7975=(($7974)|0);
14700       HEAP32[(($7975)>>2)]=$7963;
14701       var $7976=$2;
14702       var $7977=(($7976+64)|0);
14703       var $7978=HEAP32[(($7977)>>2)];
14704       var $7979=$st;
14705       var $7980=(($7979+2)|0);
14706       var $7981=$7980;
14707       var $7982=HEAP16[(($7981)>>1)];
14708       var $7983=(($7982)&65535);
14709       var $7984=(($7978+($7983<<2))|0);
14710       var $7985=$7984;
14711       var $7986=$7985;
14712       var $7987=(($7986+4)|0);
14713       var $7988=HEAP32[(($7987)>>2)];
14714       var $7989=$2;
14715       var $7990=(($7989+64)|0);
14716       var $7991=HEAP32[(($7990)>>2)];
14717       var $7992=$st;
14718       var $7993=(($7992+4)|0);
14719       var $7994=$7993;
14720       var $7995=HEAP16[(($7994)>>1)];
14721       var $7996=(($7995)&65535);
14722       var $7997=(($7991+($7996<<2))|0);
14723       var $7998=$7997;
14724       var $7999=$7998;
14725       var $8000=(($7999+4)|0);
14726       HEAP32[(($8000)>>2)]=$7988;
14727       var $8001=$2;
14728       var $8002=(($8001+64)|0);
14729       var $8003=HEAP32[(($8002)>>2)];
14730       var $8004=$st;
14731       var $8005=(($8004+2)|0);
14732       var $8006=$8005;
14733       var $8007=HEAP16[(($8006)>>1)];
14734       var $8008=(($8007)&65535);
14735       var $8009=(($8003+($8008<<2))|0);
14736       var $8010=$8009;
14737       var $8011=$8010;
14738       var $8012=(($8011+8)|0);
14739       var $8013=HEAP32[(($8012)>>2)];
14740       var $8014=$2;
14741       var $8015=(($8014+64)|0);
14742       var $8016=HEAP32[(($8015)>>2)];
14743       var $8017=$st;
14744       var $8018=(($8017+4)|0);
14745       var $8019=$8018;
14746       var $8020=HEAP16[(($8019)>>1)];
14747       var $8021=(($8020)&65535);
14748       var $8022=(($8016+($8021<<2))|0);
14749       var $8023=$8022;
14750       var $8024=$8023;
14751       var $8025=(($8024+8)|0);
14752       HEAP32[(($8025)>>2)]=$8013;
14753       __label__ = 366; break;
14754     case 305:
14755       var $8027=$2;
14756       var $8028=(($8027+64)|0);
14757       var $8029=HEAP32[(($8028)>>2)];
14758       var $8030=$st;
14759       var $8031=(($8030+4)|0);
14760       var $8032=$8031;
14761       var $8033=HEAP16[(($8032)>>1)];
14762       var $8034=(($8033)&65535);
14763       var $8035=(($8029+($8034<<2))|0);
14764       var $8036=$8035;
14765       var $8037=$8036;
14766       var $8038=HEAP32[(($8037)>>2)];
14767       var $8039=(($8038)|0) < 0;
14768       if ($8039) { __label__ = 307; break; } else { __label__ = 306; break; }
14769     case 306:
14770       var $8041=$2;
14771       var $8042=(($8041+64)|0);
14772       var $8043=HEAP32[(($8042)>>2)];
14773       var $8044=$st;
14774       var $8045=(($8044+4)|0);
14775       var $8046=$8045;
14776       var $8047=HEAP16[(($8046)>>1)];
14777       var $8048=(($8047)&65535);
14778       var $8049=(($8043+($8048<<2))|0);
14779       var $8050=$8049;
14780       var $8051=$8050;
14781       var $8052=HEAP32[(($8051)>>2)];
14782       var $8053=$2;
14783       var $8054=(($8053+80)|0);
14784       var $8055=HEAP32[(($8054)>>2)];
14785       var $8056=(($8052)>>>0) >= (($8055)>>>0);
14786       if ($8056) { __label__ = 307; break; } else { __label__ = 308; break; }
14787     case 307:
14788       var $8058=$2;
14789       var $8059=$2;
14790       var $8060=(($8059)|0);
14791       var $8061=HEAP32[(($8060)>>2)];
14792       var $8062=$2;
14793       var $8063=(($8062+64)|0);
14794       var $8064=HEAP32[(($8063)>>2)];
14795       var $8065=$st;
14796       var $8066=(($8065+4)|0);
14797       var $8067=$8066;
14798       var $8068=HEAP16[(($8067)>>1)];
14799       var $8069=(($8068)&65535);
14800       var $8070=(($8064+($8069<<2))|0);
14801       var $8071=$8070;
14802       var $8072=$8071;
14803       var $8073=HEAP32[(($8072)>>2)];
14804       _qcvmerror($8058, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8061,HEAP32[(((tempInt)+(4))>>2)]=$8073,tempInt));
14805       __label__ = 488; break;
14806     case 308:
14807       var $8075=$2;
14808       var $8076=(($8075+64)|0);
14809       var $8077=HEAP32[(($8076)>>2)];
14810       var $8078=$st;
14811       var $8079=(($8078+4)|0);
14812       var $8080=$8079;
14813       var $8081=HEAP16[(($8080)>>1)];
14814       var $8082=(($8081)&65535);
14815       var $8083=(($8077+($8082<<2))|0);
14816       var $8084=$8083;
14817       var $8085=$8084;
14818       var $8086=HEAP32[(($8085)>>2)];
14819       var $8087=$2;
14820       var $8088=(($8087+144)|0);
14821       var $8089=HEAP32[(($8088)>>2)];
14822       var $8090=(($8086)>>>0) < (($8089)>>>0);
14823       if ($8090) { __label__ = 309; break; } else { __label__ = 311; break; }
14824     case 309:
14825       var $8092=$2;
14826       var $8093=(($8092+148)|0);
14827       var $8094=HEAP8[($8093)];
14828       var $8095=(($8094) & 1);
14829       if ($8095) { __label__ = 311; break; } else { __label__ = 310; break; }
14830     case 310:
14831       var $8097=$2;
14832       var $8098=$2;
14833       var $8099=(($8098)|0);
14834       var $8100=HEAP32[(($8099)>>2)];
14835       var $8101=$2;
14836       var $8102=$2;
14837       var $8103=$2;
14838       var $8104=(($8103+64)|0);
14839       var $8105=HEAP32[(($8104)>>2)];
14840       var $8106=$st;
14841       var $8107=(($8106+4)|0);
14842       var $8108=$8107;
14843       var $8109=HEAP16[(($8108)>>1)];
14844       var $8110=(($8109)&65535);
14845       var $8111=(($8105+($8110<<2))|0);
14846       var $8112=$8111;
14847       var $8113=$8112;
14848       var $8114=HEAP32[(($8113)>>2)];
14849       var $8115=_prog_entfield($8102, $8114);
14850       var $8116=(($8115+4)|0);
14851       var $8117=HEAP32[(($8116)>>2)];
14852       var $8118=_prog_getstring($8101, $8117);
14853       var $8119=$2;
14854       var $8120=(($8119+64)|0);
14855       var $8121=HEAP32[(($8120)>>2)];
14856       var $8122=$st;
14857       var $8123=(($8122+4)|0);
14858       var $8124=$8123;
14859       var $8125=HEAP16[(($8124)>>1)];
14860       var $8126=(($8125)&65535);
14861       var $8127=(($8121+($8126<<2))|0);
14862       var $8128=$8127;
14863       var $8129=$8128;
14864       var $8130=HEAP32[(($8129)>>2)];
14865       _qcvmerror($8097, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8100,HEAP32[(((tempInt)+(4))>>2)]=$8118,HEAP32[(((tempInt)+(8))>>2)]=$8130,tempInt));
14866       __label__ = 311; break;
14867     case 311:
14868       var $8132=$2;
14869       var $8133=(($8132+76)|0);
14870       var $8134=HEAP32[(($8133)>>2)];
14871       var $8135=$2;
14872       var $8136=(($8135+64)|0);
14873       var $8137=HEAP32[(($8136)>>2)];
14874       var $8138=$st;
14875       var $8139=(($8138+4)|0);
14876       var $8140=$8139;
14877       var $8141=HEAP16[(($8140)>>1)];
14878       var $8142=(($8141)&65535);
14879       var $8143=(($8137+($8142<<2))|0);
14880       var $8144=$8143;
14881       var $8145=$8144;
14882       var $8146=HEAP32[(($8145)>>2)];
14883       var $8147=(($8134+($8146<<2))|0);
14884       var $8148=$8147;
14885       $ptr7=$8148;
14886       var $8149=$2;
14887       var $8150=(($8149+64)|0);
14888       var $8151=HEAP32[(($8150)>>2)];
14889       var $8152=$st;
14890       var $8153=(($8152+2)|0);
14891       var $8154=$8153;
14892       var $8155=HEAP16[(($8154)>>1)];
14893       var $8156=(($8155)&65535);
14894       var $8157=(($8151+($8156<<2))|0);
14895       var $8158=$8157;
14896       var $8159=$8158;
14897       var $8160=HEAP32[(($8159)>>2)];
14898       var $8161=$ptr7;
14899       var $8162=$8161;
14900       HEAP32[(($8162)>>2)]=$8160;
14901       __label__ = 366; break;
14902     case 312:
14903       var $8164=$2;
14904       var $8165=(($8164+64)|0);
14905       var $8166=HEAP32[(($8165)>>2)];
14906       var $8167=$st;
14907       var $8168=(($8167+4)|0);
14908       var $8169=$8168;
14909       var $8170=HEAP16[(($8169)>>1)];
14910       var $8171=(($8170)&65535);
14911       var $8172=(($8166+($8171<<2))|0);
14912       var $8173=$8172;
14913       var $8174=$8173;
14914       var $8175=HEAP32[(($8174)>>2)];
14915       var $8176=(($8175)|0) < 0;
14916       if ($8176) { __label__ = 314; break; } else { __label__ = 313; break; }
14917     case 313:
14918       var $8178=$2;
14919       var $8179=(($8178+64)|0);
14920       var $8180=HEAP32[(($8179)>>2)];
14921       var $8181=$st;
14922       var $8182=(($8181+4)|0);
14923       var $8183=$8182;
14924       var $8184=HEAP16[(($8183)>>1)];
14925       var $8185=(($8184)&65535);
14926       var $8186=(($8180+($8185<<2))|0);
14927       var $8187=$8186;
14928       var $8188=$8187;
14929       var $8189=HEAP32[(($8188)>>2)];
14930       var $8190=((($8189)+(2))|0);
14931       var $8191=$2;
14932       var $8192=(($8191+80)|0);
14933       var $8193=HEAP32[(($8192)>>2)];
14934       var $8194=(($8190)>>>0) >= (($8193)>>>0);
14935       if ($8194) { __label__ = 314; break; } else { __label__ = 315; break; }
14936     case 314:
14937       var $8196=$2;
14938       var $8197=$2;
14939       var $8198=(($8197)|0);
14940       var $8199=HEAP32[(($8198)>>2)];
14941       var $8200=$2;
14942       var $8201=(($8200+64)|0);
14943       var $8202=HEAP32[(($8201)>>2)];
14944       var $8203=$st;
14945       var $8204=(($8203+4)|0);
14946       var $8205=$8204;
14947       var $8206=HEAP16[(($8205)>>1)];
14948       var $8207=(($8206)&65535);
14949       var $8208=(($8202+($8207<<2))|0);
14950       var $8209=$8208;
14951       var $8210=$8209;
14952       var $8211=HEAP32[(($8210)>>2)];
14953       _qcvmerror($8196, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8199,HEAP32[(((tempInt)+(4))>>2)]=$8211,tempInt));
14954       __label__ = 488; break;
14955     case 315:
14956       var $8213=$2;
14957       var $8214=(($8213+64)|0);
14958       var $8215=HEAP32[(($8214)>>2)];
14959       var $8216=$st;
14960       var $8217=(($8216+4)|0);
14961       var $8218=$8217;
14962       var $8219=HEAP16[(($8218)>>1)];
14963       var $8220=(($8219)&65535);
14964       var $8221=(($8215+($8220<<2))|0);
14965       var $8222=$8221;
14966       var $8223=$8222;
14967       var $8224=HEAP32[(($8223)>>2)];
14968       var $8225=$2;
14969       var $8226=(($8225+144)|0);
14970       var $8227=HEAP32[(($8226)>>2)];
14971       var $8228=(($8224)>>>0) < (($8227)>>>0);
14972       if ($8228) { __label__ = 316; break; } else { __label__ = 318; break; }
14973     case 316:
14974       var $8230=$2;
14975       var $8231=(($8230+148)|0);
14976       var $8232=HEAP8[($8231)];
14977       var $8233=(($8232) & 1);
14978       if ($8233) { __label__ = 318; break; } else { __label__ = 317; break; }
14979     case 317:
14980       var $8235=$2;
14981       var $8236=$2;
14982       var $8237=(($8236)|0);
14983       var $8238=HEAP32[(($8237)>>2)];
14984       var $8239=$2;
14985       var $8240=$2;
14986       var $8241=$2;
14987       var $8242=(($8241+64)|0);
14988       var $8243=HEAP32[(($8242)>>2)];
14989       var $8244=$st;
14990       var $8245=(($8244+4)|0);
14991       var $8246=$8245;
14992       var $8247=HEAP16[(($8246)>>1)];
14993       var $8248=(($8247)&65535);
14994       var $8249=(($8243+($8248<<2))|0);
14995       var $8250=$8249;
14996       var $8251=$8250;
14997       var $8252=HEAP32[(($8251)>>2)];
14998       var $8253=_prog_entfield($8240, $8252);
14999       var $8254=(($8253+4)|0);
15000       var $8255=HEAP32[(($8254)>>2)];
15001       var $8256=_prog_getstring($8239, $8255);
15002       var $8257=$2;
15003       var $8258=(($8257+64)|0);
15004       var $8259=HEAP32[(($8258)>>2)];
15005       var $8260=$st;
15006       var $8261=(($8260+4)|0);
15007       var $8262=$8261;
15008       var $8263=HEAP16[(($8262)>>1)];
15009       var $8264=(($8263)&65535);
15010       var $8265=(($8259+($8264<<2))|0);
15011       var $8266=$8265;
15012       var $8267=$8266;
15013       var $8268=HEAP32[(($8267)>>2)];
15014       _qcvmerror($8235, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8238,HEAP32[(((tempInt)+(4))>>2)]=$8256,HEAP32[(((tempInt)+(8))>>2)]=$8268,tempInt));
15015       __label__ = 318; break;
15016     case 318:
15017       var $8270=$2;
15018       var $8271=(($8270+76)|0);
15019       var $8272=HEAP32[(($8271)>>2)];
15020       var $8273=$2;
15021       var $8274=(($8273+64)|0);
15022       var $8275=HEAP32[(($8274)>>2)];
15023       var $8276=$st;
15024       var $8277=(($8276+4)|0);
15025       var $8278=$8277;
15026       var $8279=HEAP16[(($8278)>>1)];
15027       var $8280=(($8279)&65535);
15028       var $8281=(($8275+($8280<<2))|0);
15029       var $8282=$8281;
15030       var $8283=$8282;
15031       var $8284=HEAP32[(($8283)>>2)];
15032       var $8285=(($8272+($8284<<2))|0);
15033       var $8286=$8285;
15034       $ptr7=$8286;
15035       var $8287=$2;
15036       var $8288=(($8287+64)|0);
15037       var $8289=HEAP32[(($8288)>>2)];
15038       var $8290=$st;
15039       var $8291=(($8290+2)|0);
15040       var $8292=$8291;
15041       var $8293=HEAP16[(($8292)>>1)];
15042       var $8294=(($8293)&65535);
15043       var $8295=(($8289+($8294<<2))|0);
15044       var $8296=$8295;
15045       var $8297=$8296;
15046       var $8298=(($8297)|0);
15047       var $8299=HEAP32[(($8298)>>2)];
15048       var $8300=$ptr7;
15049       var $8301=$8300;
15050       var $8302=(($8301)|0);
15051       HEAP32[(($8302)>>2)]=$8299;
15052       var $8303=$2;
15053       var $8304=(($8303+64)|0);
15054       var $8305=HEAP32[(($8304)>>2)];
15055       var $8306=$st;
15056       var $8307=(($8306+2)|0);
15057       var $8308=$8307;
15058       var $8309=HEAP16[(($8308)>>1)];
15059       var $8310=(($8309)&65535);
15060       var $8311=(($8305+($8310<<2))|0);
15061       var $8312=$8311;
15062       var $8313=$8312;
15063       var $8314=(($8313+4)|0);
15064       var $8315=HEAP32[(($8314)>>2)];
15065       var $8316=$ptr7;
15066       var $8317=$8316;
15067       var $8318=(($8317+4)|0);
15068       HEAP32[(($8318)>>2)]=$8315;
15069       var $8319=$2;
15070       var $8320=(($8319+64)|0);
15071       var $8321=HEAP32[(($8320)>>2)];
15072       var $8322=$st;
15073       var $8323=(($8322+2)|0);
15074       var $8324=$8323;
15075       var $8325=HEAP16[(($8324)>>1)];
15076       var $8326=(($8325)&65535);
15077       var $8327=(($8321+($8326<<2))|0);
15078       var $8328=$8327;
15079       var $8329=$8328;
15080       var $8330=(($8329+8)|0);
15081       var $8331=HEAP32[(($8330)>>2)];
15082       var $8332=$ptr7;
15083       var $8333=$8332;
15084       var $8334=(($8333+8)|0);
15085       HEAP32[(($8334)>>2)]=$8331;
15086       __label__ = 366; break;
15087     case 319:
15088       var $8336=$2;
15089       var $8337=(($8336+64)|0);
15090       var $8338=HEAP32[(($8337)>>2)];
15091       var $8339=$st;
15092       var $8340=(($8339+2)|0);
15093       var $8341=$8340;
15094       var $8342=HEAP16[(($8341)>>1)];
15095       var $8343=(($8342)&65535);
15096       var $8344=(($8338+($8343<<2))|0);
15097       var $8345=$8344;
15098       var $8346=$8345;
15099       var $8347=HEAP32[(($8346)>>2)];
15100       var $8348=$8347 & 2147483647;
15101       var $8349=(($8348)|0)!=0;
15102       var $8350=$8349 ^ 1;
15103       var $8351=(($8350)&1);
15104       var $8352=(($8351)|0);
15105       var $8353=$2;
15106       var $8354=(($8353+64)|0);
15107       var $8355=HEAP32[(($8354)>>2)];
15108       var $8356=$st;
15109       var $8357=(($8356+6)|0);
15110       var $8358=$8357;
15111       var $8359=HEAP16[(($8358)>>1)];
15112       var $8360=(($8359)&65535);
15113       var $8361=(($8355+($8360<<2))|0);
15114       var $8362=$8361;
15115       var $8363=$8362;
15116       HEAPF32[(($8363)>>2)]=$8352;
15117       __label__ = 366; break;
15118     case 320:
15119       var $8365=$2;
15120       var $8366=(($8365+64)|0);
15121       var $8367=HEAP32[(($8366)>>2)];
15122       var $8368=$st;
15123       var $8369=(($8368+2)|0);
15124       var $8370=$8369;
15125       var $8371=HEAP16[(($8370)>>1)];
15126       var $8372=(($8371)&65535);
15127       var $8373=(($8367+($8372<<2))|0);
15128       var $8374=$8373;
15129       var $8375=$8374;
15130       var $8376=(($8375)|0);
15131       var $8377=HEAPF32[(($8376)>>2)];
15132       var $8378=$8377 != 0;
15133       if ($8378) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 321; break; }
15134     case 321:
15135       var $8380=$2;
15136       var $8381=(($8380+64)|0);
15137       var $8382=HEAP32[(($8381)>>2)];
15138       var $8383=$st;
15139       var $8384=(($8383+2)|0);
15140       var $8385=$8384;
15141       var $8386=HEAP16[(($8385)>>1)];
15142       var $8387=(($8386)&65535);
15143       var $8388=(($8382+($8387<<2))|0);
15144       var $8389=$8388;
15145       var $8390=$8389;
15146       var $8391=(($8390+4)|0);
15147       var $8392=HEAPF32[(($8391)>>2)];
15148       var $8393=$8392 != 0;
15149       if ($8393) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 322; break; }
15150     case 322:
15151       var $8395=$2;
15152       var $8396=(($8395+64)|0);
15153       var $8397=HEAP32[(($8396)>>2)];
15154       var $8398=$st;
15155       var $8399=(($8398+2)|0);
15156       var $8400=$8399;
15157       var $8401=HEAP16[(($8400)>>1)];
15158       var $8402=(($8401)&65535);
15159       var $8403=(($8397+($8402<<2))|0);
15160       var $8404=$8403;
15161       var $8405=$8404;
15162       var $8406=(($8405+8)|0);
15163       var $8407=HEAPF32[(($8406)>>2)];
15164       var $8408=$8407 != 0;
15165       var $8409=$8408 ^ 1;
15166       var $8411 = $8409;__label__ = 323; break;
15167     case 323:
15168       var $8411;
15169       var $8412=(($8411)&1);
15170       var $8413=(($8412)|0);
15171       var $8414=$2;
15172       var $8415=(($8414+64)|0);
15173       var $8416=HEAP32[(($8415)>>2)];
15174       var $8417=$st;
15175       var $8418=(($8417+6)|0);
15176       var $8419=$8418;
15177       var $8420=HEAP16[(($8419)>>1)];
15178       var $8421=(($8420)&65535);
15179       var $8422=(($8416+($8421<<2))|0);
15180       var $8423=$8422;
15181       var $8424=$8423;
15182       HEAPF32[(($8424)>>2)]=$8413;
15183       __label__ = 366; break;
15184     case 324:
15185       var $8426=$2;
15186       var $8427=(($8426+64)|0);
15187       var $8428=HEAP32[(($8427)>>2)];
15188       var $8429=$st;
15189       var $8430=(($8429+2)|0);
15190       var $8431=$8430;
15191       var $8432=HEAP16[(($8431)>>1)];
15192       var $8433=(($8432)&65535);
15193       var $8434=(($8428+($8433<<2))|0);
15194       var $8435=$8434;
15195       var $8436=$8435;
15196       var $8437=HEAP32[(($8436)>>2)];
15197       var $8438=(($8437)|0)!=0;
15198       if ($8438) { __label__ = 325; break; } else { var $8458 = 1;__label__ = 326; break; }
15199     case 325:
15200       var $8440=$2;
15201       var $8441=$2;
15202       var $8442=(($8441+64)|0);
15203       var $8443=HEAP32[(($8442)>>2)];
15204       var $8444=$st;
15205       var $8445=(($8444+2)|0);
15206       var $8446=$8445;
15207       var $8447=HEAP16[(($8446)>>1)];
15208       var $8448=(($8447)&65535);
15209       var $8449=(($8443+($8448<<2))|0);
15210       var $8450=$8449;
15211       var $8451=$8450;
15212       var $8452=HEAP32[(($8451)>>2)];
15213       var $8453=_prog_getstring($8440, $8452);
15214       var $8454=HEAP8[($8453)];
15215       var $8455=(($8454 << 24) >> 24)!=0;
15216       var $8456=$8455 ^ 1;
15217       var $8458 = $8456;__label__ = 326; break;
15218     case 326:
15219       var $8458;
15220       var $8459=(($8458)&1);
15221       var $8460=(($8459)|0);
15222       var $8461=$2;
15223       var $8462=(($8461+64)|0);
15224       var $8463=HEAP32[(($8462)>>2)];
15225       var $8464=$st;
15226       var $8465=(($8464+6)|0);
15227       var $8466=$8465;
15228       var $8467=HEAP16[(($8466)>>1)];
15229       var $8468=(($8467)&65535);
15230       var $8469=(($8463+($8468<<2))|0);
15231       var $8470=$8469;
15232       var $8471=$8470;
15233       HEAPF32[(($8471)>>2)]=$8460;
15234       __label__ = 366; break;
15235     case 327:
15236       var $8473=$2;
15237       var $8474=(($8473+64)|0);
15238       var $8475=HEAP32[(($8474)>>2)];
15239       var $8476=$st;
15240       var $8477=(($8476+2)|0);
15241       var $8478=$8477;
15242       var $8479=HEAP16[(($8478)>>1)];
15243       var $8480=(($8479)&65535);
15244       var $8481=(($8475+($8480<<2))|0);
15245       var $8482=$8481;
15246       var $8483=$8482;
15247       var $8484=HEAP32[(($8483)>>2)];
15248       var $8485=(($8484)|0)==0;
15249       var $8486=(($8485)&1);
15250       var $8487=(($8486)|0);
15251       var $8488=$2;
15252       var $8489=(($8488+64)|0);
15253       var $8490=HEAP32[(($8489)>>2)];
15254       var $8491=$st;
15255       var $8492=(($8491+6)|0);
15256       var $8493=$8492;
15257       var $8494=HEAP16[(($8493)>>1)];
15258       var $8495=(($8494)&65535);
15259       var $8496=(($8490+($8495<<2))|0);
15260       var $8497=$8496;
15261       var $8498=$8497;
15262       HEAPF32[(($8498)>>2)]=$8487;
15263       __label__ = 366; break;
15264     case 328:
15265       var $8500=$2;
15266       var $8501=(($8500+64)|0);
15267       var $8502=HEAP32[(($8501)>>2)];
15268       var $8503=$st;
15269       var $8504=(($8503+2)|0);
15270       var $8505=$8504;
15271       var $8506=HEAP16[(($8505)>>1)];
15272       var $8507=(($8506)&65535);
15273       var $8508=(($8502+($8507<<2))|0);
15274       var $8509=$8508;
15275       var $8510=$8509;
15276       var $8511=HEAP32[(($8510)>>2)];
15277       var $8512=(($8511)|0)!=0;
15278       var $8513=$8512 ^ 1;
15279       var $8514=(($8513)&1);
15280       var $8515=(($8514)|0);
15281       var $8516=$2;
15282       var $8517=(($8516+64)|0);
15283       var $8518=HEAP32[(($8517)>>2)];
15284       var $8519=$st;
15285       var $8520=(($8519+6)|0);
15286       var $8521=$8520;
15287       var $8522=HEAP16[(($8521)>>1)];
15288       var $8523=(($8522)&65535);
15289       var $8524=(($8518+($8523<<2))|0);
15290       var $8525=$8524;
15291       var $8526=$8525;
15292       HEAPF32[(($8526)>>2)]=$8515;
15293       __label__ = 366; break;
15294     case 329:
15295       var $8528=$2;
15296       var $8529=(($8528+64)|0);
15297       var $8530=HEAP32[(($8529)>>2)];
15298       var $8531=$st;
15299       var $8532=(($8531+2)|0);
15300       var $8533=$8532;
15301       var $8534=HEAP16[(($8533)>>1)];
15302       var $8535=(($8534)&65535);
15303       var $8536=(($8530+($8535<<2))|0);
15304       var $8537=$8536;
15305       var $8538=$8537;
15306       var $8539=HEAP32[(($8538)>>2)];
15307       var $8540=$8539 & 2147483647;
15308       var $8541=(($8540)|0)!=0;
15309       if ($8541) { __label__ = 330; break; } else { __label__ = 333; break; }
15310     case 330:
15311       var $8543=$st;
15312       var $8544=(($8543+4)|0);
15313       var $8545=$8544;
15314       var $8546=HEAP16[(($8545)>>1)];
15315       var $8547=(($8546 << 16) >> 16);
15316       var $8548=((($8547)-(1))|0);
15317       var $8549=$st;
15318       var $8550=(($8549+($8548<<3))|0);
15319       $st=$8550;
15320       var $8551=$jumpcount;
15321       var $8552=((($8551)+(1))|0);
15322       $jumpcount=$8552;
15323       var $8553=$5;
15324       var $8554=(($8552)|0) >= (($8553)|0);
15325       if ($8554) { __label__ = 331; break; } else { __label__ = 332; break; }
15326     case 331:
15327       var $8556=$2;
15328       var $8557=$2;
15329       var $8558=(($8557)|0);
15330       var $8559=HEAP32[(($8558)>>2)];
15331       var $8560=$jumpcount;
15332       _qcvmerror($8556, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8559,HEAP32[(((tempInt)+(4))>>2)]=$8560,tempInt));
15333       __label__ = 332; break;
15334     case 332:
15335       __label__ = 333; break;
15336     case 333:
15337       __label__ = 366; break;
15338     case 334:
15339       var $8564=$2;
15340       var $8565=(($8564+64)|0);
15341       var $8566=HEAP32[(($8565)>>2)];
15342       var $8567=$st;
15343       var $8568=(($8567+2)|0);
15344       var $8569=$8568;
15345       var $8570=HEAP16[(($8569)>>1)];
15346       var $8571=(($8570)&65535);
15347       var $8572=(($8566+($8571<<2))|0);
15348       var $8573=$8572;
15349       var $8574=$8573;
15350       var $8575=HEAP32[(($8574)>>2)];
15351       var $8576=$8575 & 2147483647;
15352       var $8577=(($8576)|0)!=0;
15353       if ($8577) { __label__ = 338; break; } else { __label__ = 335; break; }
15354     case 335:
15355       var $8579=$st;
15356       var $8580=(($8579+4)|0);
15357       var $8581=$8580;
15358       var $8582=HEAP16[(($8581)>>1)];
15359       var $8583=(($8582 << 16) >> 16);
15360       var $8584=((($8583)-(1))|0);
15361       var $8585=$st;
15362       var $8586=(($8585+($8584<<3))|0);
15363       $st=$8586;
15364       var $8587=$jumpcount;
15365       var $8588=((($8587)+(1))|0);
15366       $jumpcount=$8588;
15367       var $8589=$5;
15368       var $8590=(($8588)|0) >= (($8589)|0);
15369       if ($8590) { __label__ = 336; break; } else { __label__ = 337; break; }
15370     case 336:
15371       var $8592=$2;
15372       var $8593=$2;
15373       var $8594=(($8593)|0);
15374       var $8595=HEAP32[(($8594)>>2)];
15375       var $8596=$jumpcount;
15376       _qcvmerror($8592, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8595,HEAP32[(((tempInt)+(4))>>2)]=$8596,tempInt));
15377       __label__ = 337; break;
15378     case 337:
15379       __label__ = 338; break;
15380     case 338:
15381       __label__ = 366; break;
15382     case 339:
15383       var $8600=$st;
15384       var $8601=(($8600)|0);
15385       var $8602=HEAP16[(($8601)>>1)];
15386       var $8603=(($8602)&65535);
15387       var $8604=((($8603)-(51))|0);
15388       var $8605=$2;
15389       var $8606=(($8605+184)|0);
15390       HEAP32[(($8606)>>2)]=$8604;
15391       var $8607=$2;
15392       var $8608=(($8607+64)|0);
15393       var $8609=HEAP32[(($8608)>>2)];
15394       var $8610=$st;
15395       var $8611=(($8610+2)|0);
15396       var $8612=$8611;
15397       var $8613=HEAP16[(($8612)>>1)];
15398       var $8614=(($8613)&65535);
15399       var $8615=(($8609+($8614<<2))|0);
15400       var $8616=$8615;
15401       var $8617=$8616;
15402       var $8618=HEAP32[(($8617)>>2)];
15403       var $8619=(($8618)|0)!=0;
15404       if ($8619) { __label__ = 341; break; } else { __label__ = 340; break; }
15405     case 340:
15406       var $8621=$2;
15407       var $8622=$2;
15408       var $8623=(($8622)|0);
15409       var $8624=HEAP32[(($8623)>>2)];
15410       _qcvmerror($8621, ((STRING_TABLE.__str23)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8624,tempInt));
15411       __label__ = 341; break;
15412     case 341:
15413       var $8626=$2;
15414       var $8627=(($8626+64)|0);
15415       var $8628=HEAP32[(($8627)>>2)];
15416       var $8629=$st;
15417       var $8630=(($8629+2)|0);
15418       var $8631=$8630;
15419       var $8632=HEAP16[(($8631)>>1)];
15420       var $8633=(($8632)&65535);
15421       var $8634=(($8628+($8633<<2))|0);
15422       var $8635=$8634;
15423       var $8636=$8635;
15424       var $8637=HEAP32[(($8636)>>2)];
15425       var $8638=(($8637)|0)!=0;
15426       if ($8638) { __label__ = 342; break; } else { __label__ = 343; break; }
15427     case 342:
15428       var $8640=$2;
15429       var $8641=(($8640+64)|0);
15430       var $8642=HEAP32[(($8641)>>2)];
15431       var $8643=$st;
15432       var $8644=(($8643+2)|0);
15433       var $8645=$8644;
15434       var $8646=HEAP16[(($8645)>>1)];
15435       var $8647=(($8646)&65535);
15436       var $8648=(($8642+($8647<<2))|0);
15437       var $8649=$8648;
15438       var $8650=$8649;
15439       var $8651=HEAP32[(($8650)>>2)];
15440       var $8652=$2;
15441       var $8653=(($8652+44)|0);
15442       var $8654=HEAP32[(($8653)>>2)];
15443       var $8655=(($8651)>>>0) >= (($8654)>>>0);
15444       if ($8655) { __label__ = 343; break; } else { __label__ = 344; break; }
15445     case 343:
15446       var $8657=$2;
15447       var $8658=$2;
15448       var $8659=(($8658)|0);
15449       var $8660=HEAP32[(($8659)>>2)];
15450       _qcvmerror($8657, ((STRING_TABLE.__str24)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8660,tempInt));
15451       __label__ = 488; break;
15452     case 344:
15453       var $8662=$2;
15454       var $8663=(($8662+64)|0);
15455       var $8664=HEAP32[(($8663)>>2)];
15456       var $8665=$st;
15457       var $8666=(($8665+2)|0);
15458       var $8667=$8666;
15459       var $8668=HEAP16[(($8667)>>1)];
15460       var $8669=(($8668)&65535);
15461       var $8670=(($8664+($8669<<2))|0);
15462       var $8671=$8670;
15463       var $8672=$8671;
15464       var $8673=HEAP32[(($8672)>>2)];
15465       var $8674=$2;
15466       var $8675=(($8674+40)|0);
15467       var $8676=HEAP32[(($8675)>>2)];
15468       var $8677=(($8676+($8673)*(36))|0);
15469       $newf5=$8677;
15470       var $8678=$newf5;
15471       var $8679=(($8678+12)|0);
15472       var $8680=HEAP32[(($8679)>>2)];
15473       var $8681=((($8680)+(1))|0);
15474       HEAP32[(($8679)>>2)]=$8681;
15475       var $8682=$st;
15476       var $8683=$2;
15477       var $8684=(($8683+4)|0);
15478       var $8685=HEAP32[(($8684)>>2)];
15479       var $8686=$8682;
15480       var $8687=$8685;
15481       var $8688=((($8686)-($8687))|0);
15482       var $8689=((((($8688)|0))/(8))&-1);
15483       var $8690=((($8689)+(1))|0);
15484       var $8691=$2;
15485       var $8692=(($8691+176)|0);
15486       HEAP32[(($8692)>>2)]=$8690;
15487       var $8693=$newf5;
15488       var $8694=(($8693)|0);
15489       var $8695=HEAP32[(($8694)>>2)];
15490       var $8696=(($8695)|0) < 0;
15491       if ($8696) { __label__ = 345; break; } else { __label__ = 350; break; }
15492     case 345:
15493       var $8698=$newf5;
15494       var $8699=(($8698)|0);
15495       var $8700=HEAP32[(($8699)>>2)];
15496       var $8701=(((-$8700))|0);
15497       $builtinnumber8=$8701;
15498       var $8702=$builtinnumber8;
15499       var $8703=$2;
15500       var $8704=(($8703+132)|0);
15501       var $8705=HEAP32[(($8704)>>2)];
15502       var $8706=(($8702)>>>0) < (($8705)>>>0);
15503       if ($8706) { __label__ = 346; break; } else { __label__ = 348; break; }
15504     case 346:
15505       var $8708=$builtinnumber8;
15506       var $8709=$2;
15507       var $8710=(($8709+128)|0);
15508       var $8711=HEAP32[(($8710)>>2)];
15509       var $8712=(($8711+($8708<<2))|0);
15510       var $8713=HEAP32[(($8712)>>2)];
15511       var $8714=(($8713)|0)!=0;
15512       if ($8714) { __label__ = 347; break; } else { __label__ = 348; break; }
15513     case 347:
15514       var $8716=$builtinnumber8;
15515       var $8717=$2;
15516       var $8718=(($8717+128)|0);
15517       var $8719=HEAP32[(($8718)>>2)];
15518       var $8720=(($8719+($8716<<2))|0);
15519       var $8721=HEAP32[(($8720)>>2)];
15520       var $8722=$2;
15521       var $8723=FUNCTION_TABLE[$8721]($8722);
15522       __label__ = 349; break;
15523     case 348:
15524       var $8725=$2;
15525       var $8726=$builtinnumber8;
15526       var $8727=$2;
15527       var $8728=(($8727)|0);
15528       var $8729=HEAP32[(($8728)>>2)];
15529       _qcvmerror($8725, ((STRING_TABLE.__str25)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8726,HEAP32[(((tempInt)+(4))>>2)]=$8729,tempInt));
15530       __label__ = 349; break;
15531     case 349:
15532       __label__ = 351; break;
15533     case 350:
15534       var $8732=$2;
15535       var $8733=(($8732+4)|0);
15536       var $8734=HEAP32[(($8733)>>2)];
15537       var $8735=$2;
15538       var $8736=$newf5;
15539       var $8737=_prog_enterfunction($8735, $8736);
15540       var $8738=(($8734+($8737<<3))|0);
15541       var $8739=((($8738)-(8))|0);
15542       $st=$8739;
15543       __label__ = 351; break;
15544     case 351:
15545       var $8741=$2;
15546       var $8742=(($8741+112)|0);
15547       var $8743=HEAP32[(($8742)>>2)];
15548       var $8744=(($8743)|0)!=0;
15549       if ($8744) { __label__ = 352; break; } else { __label__ = 353; break; }
15550     case 352:
15551       __label__ = 488; break;
15552     case 353:
15553       __label__ = 366; break;
15554     case 354:
15555       var $8748=$2;
15556       var $8749=$2;
15557       var $8750=(($8749)|0);
15558       var $8751=HEAP32[(($8750)>>2)];
15559       _qcvmerror($8748, ((STRING_TABLE.__str26)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8751,tempInt));
15560       __label__ = 366; break;
15561     case 355:
15562       var $8753=$st;
15563       var $8754=(($8753+2)|0);
15564       var $8755=$8754;
15565       var $8756=HEAP16[(($8755)>>1)];
15566       var $8757=(($8756 << 16) >> 16);
15567       var $8758=((($8757)-(1))|0);
15568       var $8759=$st;
15569       var $8760=(($8759+($8758<<3))|0);
15570       $st=$8760;
15571       var $8761=$jumpcount;
15572       var $8762=((($8761)+(1))|0);
15573       $jumpcount=$8762;
15574       var $8763=(($8762)|0)==10000000;
15575       if ($8763) { __label__ = 356; break; } else { __label__ = 357; break; }
15576     case 356:
15577       var $8765=$2;
15578       var $8766=$2;
15579       var $8767=(($8766)|0);
15580       var $8768=HEAP32[(($8767)>>2)];
15581       var $8769=$jumpcount;
15582       _qcvmerror($8765, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8768,HEAP32[(((tempInt)+(4))>>2)]=$8769,tempInt));
15583       __label__ = 357; break;
15584     case 357:
15585       __label__ = 366; break;
15586     case 358:
15587       var $8772=$2;
15588       var $8773=(($8772+64)|0);
15589       var $8774=HEAP32[(($8773)>>2)];
15590       var $8775=$st;
15591       var $8776=(($8775+2)|0);
15592       var $8777=$8776;
15593       var $8778=HEAP16[(($8777)>>1)];
15594       var $8779=(($8778)&65535);
15595       var $8780=(($8774+($8779<<2))|0);
15596       var $8781=$8780;
15597       var $8782=$8781;
15598       var $8783=HEAP32[(($8782)>>2)];
15599       var $8784=$8783 & 2147483647;
15600       var $8785=(($8784)|0)!=0;
15601       if ($8785) { __label__ = 359; break; } else { var $8802 = 0;__label__ = 360; break; }
15602     case 359:
15603       var $8787=$2;
15604       var $8788=(($8787+64)|0);
15605       var $8789=HEAP32[(($8788)>>2)];
15606       var $8790=$st;
15607       var $8791=(($8790+4)|0);
15608       var $8792=$8791;
15609       var $8793=HEAP16[(($8792)>>1)];
15610       var $8794=(($8793)&65535);
15611       var $8795=(($8789+($8794<<2))|0);
15612       var $8796=$8795;
15613       var $8797=$8796;
15614       var $8798=HEAP32[(($8797)>>2)];
15615       var $8799=$8798 & 2147483647;
15616       var $8800=(($8799)|0)!=0;
15617       var $8802 = $8800;__label__ = 360; break;
15618     case 360:
15619       var $8802;
15620       var $8803=(($8802)&1);
15621       var $8804=(($8803)|0);
15622       var $8805=$2;
15623       var $8806=(($8805+64)|0);
15624       var $8807=HEAP32[(($8806)>>2)];
15625       var $8808=$st;
15626       var $8809=(($8808+6)|0);
15627       var $8810=$8809;
15628       var $8811=HEAP16[(($8810)>>1)];
15629       var $8812=(($8811)&65535);
15630       var $8813=(($8807+($8812<<2))|0);
15631       var $8814=$8813;
15632       var $8815=$8814;
15633       HEAPF32[(($8815)>>2)]=$8804;
15634       __label__ = 366; break;
15635     case 361:
15636       var $8817=$2;
15637       var $8818=(($8817+64)|0);
15638       var $8819=HEAP32[(($8818)>>2)];
15639       var $8820=$st;
15640       var $8821=(($8820+2)|0);
15641       var $8822=$8821;
15642       var $8823=HEAP16[(($8822)>>1)];
15643       var $8824=(($8823)&65535);
15644       var $8825=(($8819+($8824<<2))|0);
15645       var $8826=$8825;
15646       var $8827=$8826;
15647       var $8828=HEAP32[(($8827)>>2)];
15648       var $8829=$8828 & 2147483647;
15649       var $8830=(($8829)|0)!=0;
15650       if ($8830) { var $8847 = 1;__label__ = 363; break; } else { __label__ = 362; break; }
15651     case 362:
15652       var $8832=$2;
15653       var $8833=(($8832+64)|0);
15654       var $8834=HEAP32[(($8833)>>2)];
15655       var $8835=$st;
15656       var $8836=(($8835+4)|0);
15657       var $8837=$8836;
15658       var $8838=HEAP16[(($8837)>>1)];
15659       var $8839=(($8838)&65535);
15660       var $8840=(($8834+($8839<<2))|0);
15661       var $8841=$8840;
15662       var $8842=$8841;
15663       var $8843=HEAP32[(($8842)>>2)];
15664       var $8844=$8843 & 2147483647;
15665       var $8845=(($8844)|0)!=0;
15666       var $8847 = $8845;__label__ = 363; break;
15667     case 363:
15668       var $8847;
15669       var $8848=(($8847)&1);
15670       var $8849=(($8848)|0);
15671       var $8850=$2;
15672       var $8851=(($8850+64)|0);
15673       var $8852=HEAP32[(($8851)>>2)];
15674       var $8853=$st;
15675       var $8854=(($8853+6)|0);
15676       var $8855=$8854;
15677       var $8856=HEAP16[(($8855)>>1)];
15678       var $8857=(($8856)&65535);
15679       var $8858=(($8852+($8857<<2))|0);
15680       var $8859=$8858;
15681       var $8860=$8859;
15682       HEAPF32[(($8860)>>2)]=$8849;
15683       __label__ = 366; break;
15684     case 364:
15685       var $8862=$2;
15686       var $8863=(($8862+64)|0);
15687       var $8864=HEAP32[(($8863)>>2)];
15688       var $8865=$st;
15689       var $8866=(($8865+2)|0);
15690       var $8867=$8866;
15691       var $8868=HEAP16[(($8867)>>1)];
15692       var $8869=(($8868)&65535);
15693       var $8870=(($8864+($8869<<2))|0);
15694       var $8871=$8870;
15695       var $8872=$8871;
15696       var $8873=HEAPF32[(($8872)>>2)];
15697       var $8874=(($8873)&-1);
15698       var $8875=$2;
15699       var $8876=(($8875+64)|0);
15700       var $8877=HEAP32[(($8876)>>2)];
15701       var $8878=$st;
15702       var $8879=(($8878+4)|0);
15703       var $8880=$8879;
15704       var $8881=HEAP16[(($8880)>>1)];
15705       var $8882=(($8881)&65535);
15706       var $8883=(($8877+($8882<<2))|0);
15707       var $8884=$8883;
15708       var $8885=$8884;
15709       var $8886=HEAPF32[(($8885)>>2)];
15710       var $8887=(($8886)&-1);
15711       var $8888=$8874 & $8887;
15712       var $8889=(($8888)|0);
15713       var $8890=$2;
15714       var $8891=(($8890+64)|0);
15715       var $8892=HEAP32[(($8891)>>2)];
15716       var $8893=$st;
15717       var $8894=(($8893+6)|0);
15718       var $8895=$8894;
15719       var $8896=HEAP16[(($8895)>>1)];
15720       var $8897=(($8896)&65535);
15721       var $8898=(($8892+($8897<<2))|0);
15722       var $8899=$8898;
15723       var $8900=$8899;
15724       HEAPF32[(($8900)>>2)]=$8889;
15725       __label__ = 366; break;
15726     case 365:
15727       var $8902=$2;
15728       var $8903=(($8902+64)|0);
15729       var $8904=HEAP32[(($8903)>>2)];
15730       var $8905=$st;
15731       var $8906=(($8905+2)|0);
15732       var $8907=$8906;
15733       var $8908=HEAP16[(($8907)>>1)];
15734       var $8909=(($8908)&65535);
15735       var $8910=(($8904+($8909<<2))|0);
15736       var $8911=$8910;
15737       var $8912=$8911;
15738       var $8913=HEAPF32[(($8912)>>2)];
15739       var $8914=(($8913)&-1);
15740       var $8915=$2;
15741       var $8916=(($8915+64)|0);
15742       var $8917=HEAP32[(($8916)>>2)];
15743       var $8918=$st;
15744       var $8919=(($8918+4)|0);
15745       var $8920=$8919;
15746       var $8921=HEAP16[(($8920)>>1)];
15747       var $8922=(($8921)&65535);
15748       var $8923=(($8917+($8922<<2))|0);
15749       var $8924=$8923;
15750       var $8925=$8924;
15751       var $8926=HEAPF32[(($8925)>>2)];
15752       var $8927=(($8926)&-1);
15753       var $8928=$8914 | $8927;
15754       var $8929=(($8928)|0);
15755       var $8930=$2;
15756       var $8931=(($8930+64)|0);
15757       var $8932=HEAP32[(($8931)>>2)];
15758       var $8933=$st;
15759       var $8934=(($8933+6)|0);
15760       var $8935=$8934;
15761       var $8936=HEAP16[(($8935)>>1)];
15762       var $8937=(($8936)&65535);
15763       var $8938=(($8932+($8937<<2))|0);
15764       var $8939=$8938;
15765       var $8940=$8939;
15766       HEAPF32[(($8940)>>2)]=$8929;
15767       __label__ = 366; break;
15768     case 366:
15769       __label__ = 247; break;
15770     case 367:
15771       __label__ = 368; break;
15772     case 368:
15773       var $8944=$st;
15774       var $8945=(($8944+8)|0);
15775       $st=$8945;
15776       var $8946=$st;
15777       var $8947=$2;
15778       var $8948=(($8947+4)|0);
15779       var $8949=HEAP32[(($8948)>>2)];
15780       var $8950=$8946;
15781       var $8951=$8949;
15782       var $8952=((($8950)-($8951))|0);
15783       var $8953=((((($8952)|0))/(8))&-1);
15784       var $8954=$2;
15785       var $8955=(($8954+116)|0);
15786       var $8956=HEAP32[(($8955)>>2)];
15787       var $8957=(($8956+($8953<<2))|0);
15788       var $8958=HEAP32[(($8957)>>2)];
15789       var $8959=((($8958)+(1))|0);
15790       HEAP32[(($8957)>>2)]=$8959;
15791       var $8960=$2;
15792       var $8961=$st;
15793       _prog_print_statement($8960, $8961);
15794       var $8962=$st;
15795       var $8963=(($8962)|0);
15796       var $8964=HEAP16[(($8963)>>1)];
15797       var $8965=(($8964)&65535);
15798       if ((($8965)|0) == 0 || (($8965)|0) == 43) {
15799         __label__ = 370; break;
15800       }
15801       else if ((($8965)|0) == 1) {
15802         __label__ = 373; break;
15803       }
15804       else if ((($8965)|0) == 2) {
15805         __label__ = 374; break;
15806       }
15807       else if ((($8965)|0) == 3) {
15808         __label__ = 375; break;
15809       }
15810       else if ((($8965)|0) == 4) {
15811         __label__ = 376; break;
15812       }
15813       else if ((($8965)|0) == 5) {
15814         __label__ = 377; break;
15815       }
15816       else if ((($8965)|0) == 6) {
15817         __label__ = 381; break;
15818       }
15819       else if ((($8965)|0) == 7) {
15820         __label__ = 382; break;
15821       }
15822       else if ((($8965)|0) == 8) {
15823         __label__ = 383; break;
15824       }
15825       else if ((($8965)|0) == 9) {
15826         __label__ = 384; break;
15827       }
15828       else if ((($8965)|0) == 10) {
15829         __label__ = 385; break;
15830       }
15831       else if ((($8965)|0) == 11) {
15832         __label__ = 386; break;
15833       }
15834       else if ((($8965)|0) == 12) {
15835         __label__ = 390; break;
15836       }
15837       else if ((($8965)|0) == 13) {
15838         __label__ = 391; break;
15839       }
15840       else if ((($8965)|0) == 14) {
15841         __label__ = 392; break;
15842       }
15843       else if ((($8965)|0) == 15) {
15844         __label__ = 393; break;
15845       }
15846       else if ((($8965)|0) == 16) {
15847         __label__ = 394; break;
15848       }
15849       else if ((($8965)|0) == 17) {
15850         __label__ = 398; break;
15851       }
15852       else if ((($8965)|0) == 18) {
15853         __label__ = 399; break;
15854       }
15855       else if ((($8965)|0) == 19) {
15856         __label__ = 400; break;
15857       }
15858       else if ((($8965)|0) == 20) {
15859         __label__ = 401; break;
15860       }
15861       else if ((($8965)|0) == 21) {
15862         __label__ = 402; break;
15863       }
15864       else if ((($8965)|0) == 22) {
15865         __label__ = 403; break;
15866       }
15867       else if ((($8965)|0) == 23) {
15868         __label__ = 404; break;
15869       }
15870       else if ((($8965)|0) == 24 || (($8965)|0) == 26 || (($8965)|0) == 28 || (($8965)|0) == 27 || (($8965)|0) == 29) {
15871         __label__ = 405; break;
15872       }
15873       else if ((($8965)|0) == 25) {
15874         __label__ = 411; break;
15875       }
15876       else if ((($8965)|0) == 30) {
15877         __label__ = 418; break;
15878       }
15879       else if ((($8965)|0) == 31 || (($8965)|0) == 33 || (($8965)|0) == 34 || (($8965)|0) == 35 || (($8965)|0) == 36) {
15880         __label__ = 424; break;
15881       }
15882       else if ((($8965)|0) == 32) {
15883         __label__ = 425; break;
15884       }
15885       else if ((($8965)|0) == 37 || (($8965)|0) == 39 || (($8965)|0) == 40 || (($8965)|0) == 41 || (($8965)|0) == 42) {
15886         __label__ = 426; break;
15887       }
15888       else if ((($8965)|0) == 38) {
15889         __label__ = 433; break;
15890       }
15891       else if ((($8965)|0) == 44) {
15892         __label__ = 440; break;
15893       }
15894       else if ((($8965)|0) == 45) {
15895         __label__ = 441; break;
15896       }
15897       else if ((($8965)|0) == 46) {
15898         __label__ = 445; break;
15899       }
15900       else if ((($8965)|0) == 47) {
15901         __label__ = 448; break;
15902       }
15903       else if ((($8965)|0) == 48) {
15904         __label__ = 449; break;
15905       }
15906       else if ((($8965)|0) == 49) {
15907         __label__ = 450; break;
15908       }
15909       else if ((($8965)|0) == 50) {
15910         __label__ = 455; break;
15911       }
15912       else if ((($8965)|0) == 51 || (($8965)|0) == 52 || (($8965)|0) == 53 || (($8965)|0) == 54 || (($8965)|0) == 55 || (($8965)|0) == 56 || (($8965)|0) == 57 || (($8965)|0) == 58 || (($8965)|0) == 59) {
15913         __label__ = 460; break;
15914       }
15915       else if ((($8965)|0) == 60) {
15916         __label__ = 475; break;
15917       }
15918       else if ((($8965)|0) == 61) {
15919         __label__ = 476; break;
15920       }
15921       else if ((($8965)|0) == 62) {
15922         __label__ = 479; break;
15923       }
15924       else if ((($8965)|0) == 63) {
15925         __label__ = 482; break;
15926       }
15927       else if ((($8965)|0) == 64) {
15928         __label__ = 485; break;
15929       }
15930       else if ((($8965)|0) == 65) {
15931         __label__ = 486; break;
15932       }
15933       else {
15934       __label__ = 369; break;
15935       }
15936
15937     case 369:
15938       var $8967=$2;
15939       var $8968=$2;
15940       var $8969=(($8968)|0);
15941       var $8970=HEAP32[(($8969)>>2)];
15942       _qcvmerror($8967, ((STRING_TABLE.__str16)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8970,tempInt));
15943       __label__ = 488; break;
15944     case 370:
15945       var $8972=$2;
15946       var $8973=(($8972+64)|0);
15947       var $8974=HEAP32[(($8973)>>2)];
15948       var $8975=$st;
15949       var $8976=(($8975+2)|0);
15950       var $8977=$8976;
15951       var $8978=HEAP16[(($8977)>>1)];
15952       var $8979=(($8978)&65535);
15953       var $8980=(($8974+($8979<<2))|0);
15954       var $8981=$8980;
15955       var $8982=$8981;
15956       var $8983=(($8982)|0);
15957       var $8984=HEAP32[(($8983)>>2)];
15958       var $8985=$2;
15959       var $8986=(($8985+64)|0);
15960       var $8987=HEAP32[(($8986)>>2)];
15961       var $8988=(($8987+4)|0);
15962       var $8989=$8988;
15963       var $8990=$8989;
15964       var $8991=(($8990)|0);
15965       HEAP32[(($8991)>>2)]=$8984;
15966       var $8992=$2;
15967       var $8993=(($8992+64)|0);
15968       var $8994=HEAP32[(($8993)>>2)];
15969       var $8995=$st;
15970       var $8996=(($8995+2)|0);
15971       var $8997=$8996;
15972       var $8998=HEAP16[(($8997)>>1)];
15973       var $8999=(($8998)&65535);
15974       var $9000=(($8994+($8999<<2))|0);
15975       var $9001=$9000;
15976       var $9002=$9001;
15977       var $9003=(($9002+4)|0);
15978       var $9004=HEAP32[(($9003)>>2)];
15979       var $9005=$2;
15980       var $9006=(($9005+64)|0);
15981       var $9007=HEAP32[(($9006)>>2)];
15982       var $9008=(($9007+4)|0);
15983       var $9009=$9008;
15984       var $9010=$9009;
15985       var $9011=(($9010+4)|0);
15986       HEAP32[(($9011)>>2)]=$9004;
15987       var $9012=$2;
15988       var $9013=(($9012+64)|0);
15989       var $9014=HEAP32[(($9013)>>2)];
15990       var $9015=$st;
15991       var $9016=(($9015+2)|0);
15992       var $9017=$9016;
15993       var $9018=HEAP16[(($9017)>>1)];
15994       var $9019=(($9018)&65535);
15995       var $9020=(($9014+($9019<<2))|0);
15996       var $9021=$9020;
15997       var $9022=$9021;
15998       var $9023=(($9022+8)|0);
15999       var $9024=HEAP32[(($9023)>>2)];
16000       var $9025=$2;
16001       var $9026=(($9025+64)|0);
16002       var $9027=HEAP32[(($9026)>>2)];
16003       var $9028=(($9027+4)|0);
16004       var $9029=$9028;
16005       var $9030=$9029;
16006       var $9031=(($9030+8)|0);
16007       HEAP32[(($9031)>>2)]=$9024;
16008       var $9032=$2;
16009       var $9033=(($9032+4)|0);
16010       var $9034=HEAP32[(($9033)>>2)];
16011       var $9035=$2;
16012       var $9036=_prog_leavefunction($9035);
16013       var $9037=(($9034+($9036<<3))|0);
16014       $st=$9037;
16015       var $9038=$2;
16016       var $9039=(($9038+168)|0);
16017       var $9040=HEAP32[(($9039)>>2)];
16018       var $9041=(($9040)|0)!=0;
16019       if ($9041) { __label__ = 372; break; } else { __label__ = 371; break; }
16020     case 371:
16021       __label__ = 488; break;
16022     case 372:
16023       __label__ = 487; break;
16024     case 373:
16025       var $9045=$2;
16026       var $9046=(($9045+64)|0);
16027       var $9047=HEAP32[(($9046)>>2)];
16028       var $9048=$st;
16029       var $9049=(($9048+2)|0);
16030       var $9050=$9049;
16031       var $9051=HEAP16[(($9050)>>1)];
16032       var $9052=(($9051)&65535);
16033       var $9053=(($9047+($9052<<2))|0);
16034       var $9054=$9053;
16035       var $9055=$9054;
16036       var $9056=HEAPF32[(($9055)>>2)];
16037       var $9057=$2;
16038       var $9058=(($9057+64)|0);
16039       var $9059=HEAP32[(($9058)>>2)];
16040       var $9060=$st;
16041       var $9061=(($9060+4)|0);
16042       var $9062=$9061;
16043       var $9063=HEAP16[(($9062)>>1)];
16044       var $9064=(($9063)&65535);
16045       var $9065=(($9059+($9064<<2))|0);
16046       var $9066=$9065;
16047       var $9067=$9066;
16048       var $9068=HEAPF32[(($9067)>>2)];
16049       var $9069=($9056)*($9068);
16050       var $9070=$2;
16051       var $9071=(($9070+64)|0);
16052       var $9072=HEAP32[(($9071)>>2)];
16053       var $9073=$st;
16054       var $9074=(($9073+6)|0);
16055       var $9075=$9074;
16056       var $9076=HEAP16[(($9075)>>1)];
16057       var $9077=(($9076)&65535);
16058       var $9078=(($9072+($9077<<2))|0);
16059       var $9079=$9078;
16060       var $9080=$9079;
16061       HEAPF32[(($9080)>>2)]=$9069;
16062       __label__ = 487; break;
16063     case 374:
16064       var $9082=$2;
16065       var $9083=(($9082+64)|0);
16066       var $9084=HEAP32[(($9083)>>2)];
16067       var $9085=$st;
16068       var $9086=(($9085+2)|0);
16069       var $9087=$9086;
16070       var $9088=HEAP16[(($9087)>>1)];
16071       var $9089=(($9088)&65535);
16072       var $9090=(($9084+($9089<<2))|0);
16073       var $9091=$9090;
16074       var $9092=$9091;
16075       var $9093=(($9092)|0);
16076       var $9094=HEAPF32[(($9093)>>2)];
16077       var $9095=$2;
16078       var $9096=(($9095+64)|0);
16079       var $9097=HEAP32[(($9096)>>2)];
16080       var $9098=$st;
16081       var $9099=(($9098+4)|0);
16082       var $9100=$9099;
16083       var $9101=HEAP16[(($9100)>>1)];
16084       var $9102=(($9101)&65535);
16085       var $9103=(($9097+($9102<<2))|0);
16086       var $9104=$9103;
16087       var $9105=$9104;
16088       var $9106=(($9105)|0);
16089       var $9107=HEAPF32[(($9106)>>2)];
16090       var $9108=($9094)*($9107);
16091       var $9109=$2;
16092       var $9110=(($9109+64)|0);
16093       var $9111=HEAP32[(($9110)>>2)];
16094       var $9112=$st;
16095       var $9113=(($9112+2)|0);
16096       var $9114=$9113;
16097       var $9115=HEAP16[(($9114)>>1)];
16098       var $9116=(($9115)&65535);
16099       var $9117=(($9111+($9116<<2))|0);
16100       var $9118=$9117;
16101       var $9119=$9118;
16102       var $9120=(($9119+4)|0);
16103       var $9121=HEAPF32[(($9120)>>2)];
16104       var $9122=$2;
16105       var $9123=(($9122+64)|0);
16106       var $9124=HEAP32[(($9123)>>2)];
16107       var $9125=$st;
16108       var $9126=(($9125+4)|0);
16109       var $9127=$9126;
16110       var $9128=HEAP16[(($9127)>>1)];
16111       var $9129=(($9128)&65535);
16112       var $9130=(($9124+($9129<<2))|0);
16113       var $9131=$9130;
16114       var $9132=$9131;
16115       var $9133=(($9132+4)|0);
16116       var $9134=HEAPF32[(($9133)>>2)];
16117       var $9135=($9121)*($9134);
16118       var $9136=($9108)+($9135);
16119       var $9137=$2;
16120       var $9138=(($9137+64)|0);
16121       var $9139=HEAP32[(($9138)>>2)];
16122       var $9140=$st;
16123       var $9141=(($9140+2)|0);
16124       var $9142=$9141;
16125       var $9143=HEAP16[(($9142)>>1)];
16126       var $9144=(($9143)&65535);
16127       var $9145=(($9139+($9144<<2))|0);
16128       var $9146=$9145;
16129       var $9147=$9146;
16130       var $9148=(($9147+8)|0);
16131       var $9149=HEAPF32[(($9148)>>2)];
16132       var $9150=$2;
16133       var $9151=(($9150+64)|0);
16134       var $9152=HEAP32[(($9151)>>2)];
16135       var $9153=$st;
16136       var $9154=(($9153+4)|0);
16137       var $9155=$9154;
16138       var $9156=HEAP16[(($9155)>>1)];
16139       var $9157=(($9156)&65535);
16140       var $9158=(($9152+($9157<<2))|0);
16141       var $9159=$9158;
16142       var $9160=$9159;
16143       var $9161=(($9160+8)|0);
16144       var $9162=HEAPF32[(($9161)>>2)];
16145       var $9163=($9149)*($9162);
16146       var $9164=($9136)+($9163);
16147       var $9165=$2;
16148       var $9166=(($9165+64)|0);
16149       var $9167=HEAP32[(($9166)>>2)];
16150       var $9168=$st;
16151       var $9169=(($9168+6)|0);
16152       var $9170=$9169;
16153       var $9171=HEAP16[(($9170)>>1)];
16154       var $9172=(($9171)&65535);
16155       var $9173=(($9167+($9172<<2))|0);
16156       var $9174=$9173;
16157       var $9175=$9174;
16158       HEAPF32[(($9175)>>2)]=$9164;
16159       __label__ = 487; break;
16160     case 375:
16161       var $9177=$2;
16162       var $9178=(($9177+64)|0);
16163       var $9179=HEAP32[(($9178)>>2)];
16164       var $9180=$st;
16165       var $9181=(($9180+2)|0);
16166       var $9182=$9181;
16167       var $9183=HEAP16[(($9182)>>1)];
16168       var $9184=(($9183)&65535);
16169       var $9185=(($9179+($9184<<2))|0);
16170       var $9186=$9185;
16171       var $9187=$9186;
16172       var $9188=HEAPF32[(($9187)>>2)];
16173       var $9189=$2;
16174       var $9190=(($9189+64)|0);
16175       var $9191=HEAP32[(($9190)>>2)];
16176       var $9192=$st;
16177       var $9193=(($9192+4)|0);
16178       var $9194=$9193;
16179       var $9195=HEAP16[(($9194)>>1)];
16180       var $9196=(($9195)&65535);
16181       var $9197=(($9191+($9196<<2))|0);
16182       var $9198=$9197;
16183       var $9199=$9198;
16184       var $9200=(($9199)|0);
16185       var $9201=HEAPF32[(($9200)>>2)];
16186       var $9202=($9188)*($9201);
16187       var $9203=$2;
16188       var $9204=(($9203+64)|0);
16189       var $9205=HEAP32[(($9204)>>2)];
16190       var $9206=$st;
16191       var $9207=(($9206+6)|0);
16192       var $9208=$9207;
16193       var $9209=HEAP16[(($9208)>>1)];
16194       var $9210=(($9209)&65535);
16195       var $9211=(($9205+($9210<<2))|0);
16196       var $9212=$9211;
16197       var $9213=$9212;
16198       var $9214=(($9213)|0);
16199       HEAPF32[(($9214)>>2)]=$9202;
16200       var $9215=$2;
16201       var $9216=(($9215+64)|0);
16202       var $9217=HEAP32[(($9216)>>2)];
16203       var $9218=$st;
16204       var $9219=(($9218+2)|0);
16205       var $9220=$9219;
16206       var $9221=HEAP16[(($9220)>>1)];
16207       var $9222=(($9221)&65535);
16208       var $9223=(($9217+($9222<<2))|0);
16209       var $9224=$9223;
16210       var $9225=$9224;
16211       var $9226=HEAPF32[(($9225)>>2)];
16212       var $9227=$2;
16213       var $9228=(($9227+64)|0);
16214       var $9229=HEAP32[(($9228)>>2)];
16215       var $9230=$st;
16216       var $9231=(($9230+4)|0);
16217       var $9232=$9231;
16218       var $9233=HEAP16[(($9232)>>1)];
16219       var $9234=(($9233)&65535);
16220       var $9235=(($9229+($9234<<2))|0);
16221       var $9236=$9235;
16222       var $9237=$9236;
16223       var $9238=(($9237+4)|0);
16224       var $9239=HEAPF32[(($9238)>>2)];
16225       var $9240=($9226)*($9239);
16226       var $9241=$2;
16227       var $9242=(($9241+64)|0);
16228       var $9243=HEAP32[(($9242)>>2)];
16229       var $9244=$st;
16230       var $9245=(($9244+6)|0);
16231       var $9246=$9245;
16232       var $9247=HEAP16[(($9246)>>1)];
16233       var $9248=(($9247)&65535);
16234       var $9249=(($9243+($9248<<2))|0);
16235       var $9250=$9249;
16236       var $9251=$9250;
16237       var $9252=(($9251+4)|0);
16238       HEAPF32[(($9252)>>2)]=$9240;
16239       var $9253=$2;
16240       var $9254=(($9253+64)|0);
16241       var $9255=HEAP32[(($9254)>>2)];
16242       var $9256=$st;
16243       var $9257=(($9256+2)|0);
16244       var $9258=$9257;
16245       var $9259=HEAP16[(($9258)>>1)];
16246       var $9260=(($9259)&65535);
16247       var $9261=(($9255+($9260<<2))|0);
16248       var $9262=$9261;
16249       var $9263=$9262;
16250       var $9264=HEAPF32[(($9263)>>2)];
16251       var $9265=$2;
16252       var $9266=(($9265+64)|0);
16253       var $9267=HEAP32[(($9266)>>2)];
16254       var $9268=$st;
16255       var $9269=(($9268+4)|0);
16256       var $9270=$9269;
16257       var $9271=HEAP16[(($9270)>>1)];
16258       var $9272=(($9271)&65535);
16259       var $9273=(($9267+($9272<<2))|0);
16260       var $9274=$9273;
16261       var $9275=$9274;
16262       var $9276=(($9275+8)|0);
16263       var $9277=HEAPF32[(($9276)>>2)];
16264       var $9278=($9264)*($9277);
16265       var $9279=$2;
16266       var $9280=(($9279+64)|0);
16267       var $9281=HEAP32[(($9280)>>2)];
16268       var $9282=$st;
16269       var $9283=(($9282+6)|0);
16270       var $9284=$9283;
16271       var $9285=HEAP16[(($9284)>>1)];
16272       var $9286=(($9285)&65535);
16273       var $9287=(($9281+($9286<<2))|0);
16274       var $9288=$9287;
16275       var $9289=$9288;
16276       var $9290=(($9289+8)|0);
16277       HEAPF32[(($9290)>>2)]=$9278;
16278       __label__ = 487; break;
16279     case 376:
16280       var $9292=$2;
16281       var $9293=(($9292+64)|0);
16282       var $9294=HEAP32[(($9293)>>2)];
16283       var $9295=$st;
16284       var $9296=(($9295+4)|0);
16285       var $9297=$9296;
16286       var $9298=HEAP16[(($9297)>>1)];
16287       var $9299=(($9298)&65535);
16288       var $9300=(($9294+($9299<<2))|0);
16289       var $9301=$9300;
16290       var $9302=$9301;
16291       var $9303=HEAPF32[(($9302)>>2)];
16292       var $9304=$2;
16293       var $9305=(($9304+64)|0);
16294       var $9306=HEAP32[(($9305)>>2)];
16295       var $9307=$st;
16296       var $9308=(($9307+2)|0);
16297       var $9309=$9308;
16298       var $9310=HEAP16[(($9309)>>1)];
16299       var $9311=(($9310)&65535);
16300       var $9312=(($9306+($9311<<2))|0);
16301       var $9313=$9312;
16302       var $9314=$9313;
16303       var $9315=(($9314)|0);
16304       var $9316=HEAPF32[(($9315)>>2)];
16305       var $9317=($9303)*($9316);
16306       var $9318=$2;
16307       var $9319=(($9318+64)|0);
16308       var $9320=HEAP32[(($9319)>>2)];
16309       var $9321=$st;
16310       var $9322=(($9321+6)|0);
16311       var $9323=$9322;
16312       var $9324=HEAP16[(($9323)>>1)];
16313       var $9325=(($9324)&65535);
16314       var $9326=(($9320+($9325<<2))|0);
16315       var $9327=$9326;
16316       var $9328=$9327;
16317       var $9329=(($9328)|0);
16318       HEAPF32[(($9329)>>2)]=$9317;
16319       var $9330=$2;
16320       var $9331=(($9330+64)|0);
16321       var $9332=HEAP32[(($9331)>>2)];
16322       var $9333=$st;
16323       var $9334=(($9333+4)|0);
16324       var $9335=$9334;
16325       var $9336=HEAP16[(($9335)>>1)];
16326       var $9337=(($9336)&65535);
16327       var $9338=(($9332+($9337<<2))|0);
16328       var $9339=$9338;
16329       var $9340=$9339;
16330       var $9341=HEAPF32[(($9340)>>2)];
16331       var $9342=$2;
16332       var $9343=(($9342+64)|0);
16333       var $9344=HEAP32[(($9343)>>2)];
16334       var $9345=$st;
16335       var $9346=(($9345+2)|0);
16336       var $9347=$9346;
16337       var $9348=HEAP16[(($9347)>>1)];
16338       var $9349=(($9348)&65535);
16339       var $9350=(($9344+($9349<<2))|0);
16340       var $9351=$9350;
16341       var $9352=$9351;
16342       var $9353=(($9352+4)|0);
16343       var $9354=HEAPF32[(($9353)>>2)];
16344       var $9355=($9341)*($9354);
16345       var $9356=$2;
16346       var $9357=(($9356+64)|0);
16347       var $9358=HEAP32[(($9357)>>2)];
16348       var $9359=$st;
16349       var $9360=(($9359+6)|0);
16350       var $9361=$9360;
16351       var $9362=HEAP16[(($9361)>>1)];
16352       var $9363=(($9362)&65535);
16353       var $9364=(($9358+($9363<<2))|0);
16354       var $9365=$9364;
16355       var $9366=$9365;
16356       var $9367=(($9366+4)|0);
16357       HEAPF32[(($9367)>>2)]=$9355;
16358       var $9368=$2;
16359       var $9369=(($9368+64)|0);
16360       var $9370=HEAP32[(($9369)>>2)];
16361       var $9371=$st;
16362       var $9372=(($9371+4)|0);
16363       var $9373=$9372;
16364       var $9374=HEAP16[(($9373)>>1)];
16365       var $9375=(($9374)&65535);
16366       var $9376=(($9370+($9375<<2))|0);
16367       var $9377=$9376;
16368       var $9378=$9377;
16369       var $9379=HEAPF32[(($9378)>>2)];
16370       var $9380=$2;
16371       var $9381=(($9380+64)|0);
16372       var $9382=HEAP32[(($9381)>>2)];
16373       var $9383=$st;
16374       var $9384=(($9383+2)|0);
16375       var $9385=$9384;
16376       var $9386=HEAP16[(($9385)>>1)];
16377       var $9387=(($9386)&65535);
16378       var $9388=(($9382+($9387<<2))|0);
16379       var $9389=$9388;
16380       var $9390=$9389;
16381       var $9391=(($9390+8)|0);
16382       var $9392=HEAPF32[(($9391)>>2)];
16383       var $9393=($9379)*($9392);
16384       var $9394=$2;
16385       var $9395=(($9394+64)|0);
16386       var $9396=HEAP32[(($9395)>>2)];
16387       var $9397=$st;
16388       var $9398=(($9397+6)|0);
16389       var $9399=$9398;
16390       var $9400=HEAP16[(($9399)>>1)];
16391       var $9401=(($9400)&65535);
16392       var $9402=(($9396+($9401<<2))|0);
16393       var $9403=$9402;
16394       var $9404=$9403;
16395       var $9405=(($9404+8)|0);
16396       HEAPF32[(($9405)>>2)]=$9393;
16397       __label__ = 487; break;
16398     case 377:
16399       var $9407=$2;
16400       var $9408=(($9407+64)|0);
16401       var $9409=HEAP32[(($9408)>>2)];
16402       var $9410=$st;
16403       var $9411=(($9410+4)|0);
16404       var $9412=$9411;
16405       var $9413=HEAP16[(($9412)>>1)];
16406       var $9414=(($9413)&65535);
16407       var $9415=(($9409+($9414<<2))|0);
16408       var $9416=$9415;
16409       var $9417=$9416;
16410       var $9418=HEAPF32[(($9417)>>2)];
16411       var $9419=$9418 != 0;
16412       if ($9419) { __label__ = 378; break; } else { __label__ = 379; break; }
16413     case 378:
16414       var $9421=$2;
16415       var $9422=(($9421+64)|0);
16416       var $9423=HEAP32[(($9422)>>2)];
16417       var $9424=$st;
16418       var $9425=(($9424+2)|0);
16419       var $9426=$9425;
16420       var $9427=HEAP16[(($9426)>>1)];
16421       var $9428=(($9427)&65535);
16422       var $9429=(($9423+($9428<<2))|0);
16423       var $9430=$9429;
16424       var $9431=$9430;
16425       var $9432=HEAPF32[(($9431)>>2)];
16426       var $9433=$2;
16427       var $9434=(($9433+64)|0);
16428       var $9435=HEAP32[(($9434)>>2)];
16429       var $9436=$st;
16430       var $9437=(($9436+4)|0);
16431       var $9438=$9437;
16432       var $9439=HEAP16[(($9438)>>1)];
16433       var $9440=(($9439)&65535);
16434       var $9441=(($9435+($9440<<2))|0);
16435       var $9442=$9441;
16436       var $9443=$9442;
16437       var $9444=HEAPF32[(($9443)>>2)];
16438       var $9445=($9432)/($9444);
16439       var $9446=$2;
16440       var $9447=(($9446+64)|0);
16441       var $9448=HEAP32[(($9447)>>2)];
16442       var $9449=$st;
16443       var $9450=(($9449+6)|0);
16444       var $9451=$9450;
16445       var $9452=HEAP16[(($9451)>>1)];
16446       var $9453=(($9452)&65535);
16447       var $9454=(($9448+($9453<<2))|0);
16448       var $9455=$9454;
16449       var $9456=$9455;
16450       HEAPF32[(($9456)>>2)]=$9445;
16451       __label__ = 380; break;
16452     case 379:
16453       var $9458=$2;
16454       var $9459=(($9458+64)|0);
16455       var $9460=HEAP32[(($9459)>>2)];
16456       var $9461=$st;
16457       var $9462=(($9461+6)|0);
16458       var $9463=$9462;
16459       var $9464=HEAP16[(($9463)>>1)];
16460       var $9465=(($9464)&65535);
16461       var $9466=(($9460+($9465<<2))|0);
16462       var $9467=$9466;
16463       var $9468=$9467;
16464       HEAPF32[(($9468)>>2)]=0;
16465       __label__ = 380; break;
16466     case 380:
16467       __label__ = 487; break;
16468     case 381:
16469       var $9471=$2;
16470       var $9472=(($9471+64)|0);
16471       var $9473=HEAP32[(($9472)>>2)];
16472       var $9474=$st;
16473       var $9475=(($9474+2)|0);
16474       var $9476=$9475;
16475       var $9477=HEAP16[(($9476)>>1)];
16476       var $9478=(($9477)&65535);
16477       var $9479=(($9473+($9478<<2))|0);
16478       var $9480=$9479;
16479       var $9481=$9480;
16480       var $9482=HEAPF32[(($9481)>>2)];
16481       var $9483=$2;
16482       var $9484=(($9483+64)|0);
16483       var $9485=HEAP32[(($9484)>>2)];
16484       var $9486=$st;
16485       var $9487=(($9486+4)|0);
16486       var $9488=$9487;
16487       var $9489=HEAP16[(($9488)>>1)];
16488       var $9490=(($9489)&65535);
16489       var $9491=(($9485+($9490<<2))|0);
16490       var $9492=$9491;
16491       var $9493=$9492;
16492       var $9494=HEAPF32[(($9493)>>2)];
16493       var $9495=($9482)+($9494);
16494       var $9496=$2;
16495       var $9497=(($9496+64)|0);
16496       var $9498=HEAP32[(($9497)>>2)];
16497       var $9499=$st;
16498       var $9500=(($9499+6)|0);
16499       var $9501=$9500;
16500       var $9502=HEAP16[(($9501)>>1)];
16501       var $9503=(($9502)&65535);
16502       var $9504=(($9498+($9503<<2))|0);
16503       var $9505=$9504;
16504       var $9506=$9505;
16505       HEAPF32[(($9506)>>2)]=$9495;
16506       __label__ = 487; break;
16507     case 382:
16508       var $9508=$2;
16509       var $9509=(($9508+64)|0);
16510       var $9510=HEAP32[(($9509)>>2)];
16511       var $9511=$st;
16512       var $9512=(($9511+2)|0);
16513       var $9513=$9512;
16514       var $9514=HEAP16[(($9513)>>1)];
16515       var $9515=(($9514)&65535);
16516       var $9516=(($9510+($9515<<2))|0);
16517       var $9517=$9516;
16518       var $9518=$9517;
16519       var $9519=(($9518)|0);
16520       var $9520=HEAPF32[(($9519)>>2)];
16521       var $9521=$2;
16522       var $9522=(($9521+64)|0);
16523       var $9523=HEAP32[(($9522)>>2)];
16524       var $9524=$st;
16525       var $9525=(($9524+4)|0);
16526       var $9526=$9525;
16527       var $9527=HEAP16[(($9526)>>1)];
16528       var $9528=(($9527)&65535);
16529       var $9529=(($9523+($9528<<2))|0);
16530       var $9530=$9529;
16531       var $9531=$9530;
16532       var $9532=(($9531)|0);
16533       var $9533=HEAPF32[(($9532)>>2)];
16534       var $9534=($9520)+($9533);
16535       var $9535=$2;
16536       var $9536=(($9535+64)|0);
16537       var $9537=HEAP32[(($9536)>>2)];
16538       var $9538=$st;
16539       var $9539=(($9538+6)|0);
16540       var $9540=$9539;
16541       var $9541=HEAP16[(($9540)>>1)];
16542       var $9542=(($9541)&65535);
16543       var $9543=(($9537+($9542<<2))|0);
16544       var $9544=$9543;
16545       var $9545=$9544;
16546       var $9546=(($9545)|0);
16547       HEAPF32[(($9546)>>2)]=$9534;
16548       var $9547=$2;
16549       var $9548=(($9547+64)|0);
16550       var $9549=HEAP32[(($9548)>>2)];
16551       var $9550=$st;
16552       var $9551=(($9550+2)|0);
16553       var $9552=$9551;
16554       var $9553=HEAP16[(($9552)>>1)];
16555       var $9554=(($9553)&65535);
16556       var $9555=(($9549+($9554<<2))|0);
16557       var $9556=$9555;
16558       var $9557=$9556;
16559       var $9558=(($9557+4)|0);
16560       var $9559=HEAPF32[(($9558)>>2)];
16561       var $9560=$2;
16562       var $9561=(($9560+64)|0);
16563       var $9562=HEAP32[(($9561)>>2)];
16564       var $9563=$st;
16565       var $9564=(($9563+4)|0);
16566       var $9565=$9564;
16567       var $9566=HEAP16[(($9565)>>1)];
16568       var $9567=(($9566)&65535);
16569       var $9568=(($9562+($9567<<2))|0);
16570       var $9569=$9568;
16571       var $9570=$9569;
16572       var $9571=(($9570+4)|0);
16573       var $9572=HEAPF32[(($9571)>>2)];
16574       var $9573=($9559)+($9572);
16575       var $9574=$2;
16576       var $9575=(($9574+64)|0);
16577       var $9576=HEAP32[(($9575)>>2)];
16578       var $9577=$st;
16579       var $9578=(($9577+6)|0);
16580       var $9579=$9578;
16581       var $9580=HEAP16[(($9579)>>1)];
16582       var $9581=(($9580)&65535);
16583       var $9582=(($9576+($9581<<2))|0);
16584       var $9583=$9582;
16585       var $9584=$9583;
16586       var $9585=(($9584+4)|0);
16587       HEAPF32[(($9585)>>2)]=$9573;
16588       var $9586=$2;
16589       var $9587=(($9586+64)|0);
16590       var $9588=HEAP32[(($9587)>>2)];
16591       var $9589=$st;
16592       var $9590=(($9589+2)|0);
16593       var $9591=$9590;
16594       var $9592=HEAP16[(($9591)>>1)];
16595       var $9593=(($9592)&65535);
16596       var $9594=(($9588+($9593<<2))|0);
16597       var $9595=$9594;
16598       var $9596=$9595;
16599       var $9597=(($9596+8)|0);
16600       var $9598=HEAPF32[(($9597)>>2)];
16601       var $9599=$2;
16602       var $9600=(($9599+64)|0);
16603       var $9601=HEAP32[(($9600)>>2)];
16604       var $9602=$st;
16605       var $9603=(($9602+4)|0);
16606       var $9604=$9603;
16607       var $9605=HEAP16[(($9604)>>1)];
16608       var $9606=(($9605)&65535);
16609       var $9607=(($9601+($9606<<2))|0);
16610       var $9608=$9607;
16611       var $9609=$9608;
16612       var $9610=(($9609+8)|0);
16613       var $9611=HEAPF32[(($9610)>>2)];
16614       var $9612=($9598)+($9611);
16615       var $9613=$2;
16616       var $9614=(($9613+64)|0);
16617       var $9615=HEAP32[(($9614)>>2)];
16618       var $9616=$st;
16619       var $9617=(($9616+6)|0);
16620       var $9618=$9617;
16621       var $9619=HEAP16[(($9618)>>1)];
16622       var $9620=(($9619)&65535);
16623       var $9621=(($9615+($9620<<2))|0);
16624       var $9622=$9621;
16625       var $9623=$9622;
16626       var $9624=(($9623+8)|0);
16627       HEAPF32[(($9624)>>2)]=$9612;
16628       __label__ = 487; break;
16629     case 383:
16630       var $9626=$2;
16631       var $9627=(($9626+64)|0);
16632       var $9628=HEAP32[(($9627)>>2)];
16633       var $9629=$st;
16634       var $9630=(($9629+2)|0);
16635       var $9631=$9630;
16636       var $9632=HEAP16[(($9631)>>1)];
16637       var $9633=(($9632)&65535);
16638       var $9634=(($9628+($9633<<2))|0);
16639       var $9635=$9634;
16640       var $9636=$9635;
16641       var $9637=HEAPF32[(($9636)>>2)];
16642       var $9638=$2;
16643       var $9639=(($9638+64)|0);
16644       var $9640=HEAP32[(($9639)>>2)];
16645       var $9641=$st;
16646       var $9642=(($9641+4)|0);
16647       var $9643=$9642;
16648       var $9644=HEAP16[(($9643)>>1)];
16649       var $9645=(($9644)&65535);
16650       var $9646=(($9640+($9645<<2))|0);
16651       var $9647=$9646;
16652       var $9648=$9647;
16653       var $9649=HEAPF32[(($9648)>>2)];
16654       var $9650=($9637)-($9649);
16655       var $9651=$2;
16656       var $9652=(($9651+64)|0);
16657       var $9653=HEAP32[(($9652)>>2)];
16658       var $9654=$st;
16659       var $9655=(($9654+6)|0);
16660       var $9656=$9655;
16661       var $9657=HEAP16[(($9656)>>1)];
16662       var $9658=(($9657)&65535);
16663       var $9659=(($9653+($9658<<2))|0);
16664       var $9660=$9659;
16665       var $9661=$9660;
16666       HEAPF32[(($9661)>>2)]=$9650;
16667       __label__ = 487; break;
16668     case 384:
16669       var $9663=$2;
16670       var $9664=(($9663+64)|0);
16671       var $9665=HEAP32[(($9664)>>2)];
16672       var $9666=$st;
16673       var $9667=(($9666+2)|0);
16674       var $9668=$9667;
16675       var $9669=HEAP16[(($9668)>>1)];
16676       var $9670=(($9669)&65535);
16677       var $9671=(($9665+($9670<<2))|0);
16678       var $9672=$9671;
16679       var $9673=$9672;
16680       var $9674=(($9673)|0);
16681       var $9675=HEAPF32[(($9674)>>2)];
16682       var $9676=$2;
16683       var $9677=(($9676+64)|0);
16684       var $9678=HEAP32[(($9677)>>2)];
16685       var $9679=$st;
16686       var $9680=(($9679+4)|0);
16687       var $9681=$9680;
16688       var $9682=HEAP16[(($9681)>>1)];
16689       var $9683=(($9682)&65535);
16690       var $9684=(($9678+($9683<<2))|0);
16691       var $9685=$9684;
16692       var $9686=$9685;
16693       var $9687=(($9686)|0);
16694       var $9688=HEAPF32[(($9687)>>2)];
16695       var $9689=($9675)-($9688);
16696       var $9690=$2;
16697       var $9691=(($9690+64)|0);
16698       var $9692=HEAP32[(($9691)>>2)];
16699       var $9693=$st;
16700       var $9694=(($9693+6)|0);
16701       var $9695=$9694;
16702       var $9696=HEAP16[(($9695)>>1)];
16703       var $9697=(($9696)&65535);
16704       var $9698=(($9692+($9697<<2))|0);
16705       var $9699=$9698;
16706       var $9700=$9699;
16707       var $9701=(($9700)|0);
16708       HEAPF32[(($9701)>>2)]=$9689;
16709       var $9702=$2;
16710       var $9703=(($9702+64)|0);
16711       var $9704=HEAP32[(($9703)>>2)];
16712       var $9705=$st;
16713       var $9706=(($9705+2)|0);
16714       var $9707=$9706;
16715       var $9708=HEAP16[(($9707)>>1)];
16716       var $9709=(($9708)&65535);
16717       var $9710=(($9704+($9709<<2))|0);
16718       var $9711=$9710;
16719       var $9712=$9711;
16720       var $9713=(($9712+4)|0);
16721       var $9714=HEAPF32[(($9713)>>2)];
16722       var $9715=$2;
16723       var $9716=(($9715+64)|0);
16724       var $9717=HEAP32[(($9716)>>2)];
16725       var $9718=$st;
16726       var $9719=(($9718+4)|0);
16727       var $9720=$9719;
16728       var $9721=HEAP16[(($9720)>>1)];
16729       var $9722=(($9721)&65535);
16730       var $9723=(($9717+($9722<<2))|0);
16731       var $9724=$9723;
16732       var $9725=$9724;
16733       var $9726=(($9725+4)|0);
16734       var $9727=HEAPF32[(($9726)>>2)];
16735       var $9728=($9714)-($9727);
16736       var $9729=$2;
16737       var $9730=(($9729+64)|0);
16738       var $9731=HEAP32[(($9730)>>2)];
16739       var $9732=$st;
16740       var $9733=(($9732+6)|0);
16741       var $9734=$9733;
16742       var $9735=HEAP16[(($9734)>>1)];
16743       var $9736=(($9735)&65535);
16744       var $9737=(($9731+($9736<<2))|0);
16745       var $9738=$9737;
16746       var $9739=$9738;
16747       var $9740=(($9739+4)|0);
16748       HEAPF32[(($9740)>>2)]=$9728;
16749       var $9741=$2;
16750       var $9742=(($9741+64)|0);
16751       var $9743=HEAP32[(($9742)>>2)];
16752       var $9744=$st;
16753       var $9745=(($9744+2)|0);
16754       var $9746=$9745;
16755       var $9747=HEAP16[(($9746)>>1)];
16756       var $9748=(($9747)&65535);
16757       var $9749=(($9743+($9748<<2))|0);
16758       var $9750=$9749;
16759       var $9751=$9750;
16760       var $9752=(($9751+8)|0);
16761       var $9753=HEAPF32[(($9752)>>2)];
16762       var $9754=$2;
16763       var $9755=(($9754+64)|0);
16764       var $9756=HEAP32[(($9755)>>2)];
16765       var $9757=$st;
16766       var $9758=(($9757+4)|0);
16767       var $9759=$9758;
16768       var $9760=HEAP16[(($9759)>>1)];
16769       var $9761=(($9760)&65535);
16770       var $9762=(($9756+($9761<<2))|0);
16771       var $9763=$9762;
16772       var $9764=$9763;
16773       var $9765=(($9764+8)|0);
16774       var $9766=HEAPF32[(($9765)>>2)];
16775       var $9767=($9753)-($9766);
16776       var $9768=$2;
16777       var $9769=(($9768+64)|0);
16778       var $9770=HEAP32[(($9769)>>2)];
16779       var $9771=$st;
16780       var $9772=(($9771+6)|0);
16781       var $9773=$9772;
16782       var $9774=HEAP16[(($9773)>>1)];
16783       var $9775=(($9774)&65535);
16784       var $9776=(($9770+($9775<<2))|0);
16785       var $9777=$9776;
16786       var $9778=$9777;
16787       var $9779=(($9778+8)|0);
16788       HEAPF32[(($9779)>>2)]=$9767;
16789       __label__ = 487; break;
16790     case 385:
16791       var $9781=$2;
16792       var $9782=(($9781+64)|0);
16793       var $9783=HEAP32[(($9782)>>2)];
16794       var $9784=$st;
16795       var $9785=(($9784+2)|0);
16796       var $9786=$9785;
16797       var $9787=HEAP16[(($9786)>>1)];
16798       var $9788=(($9787)&65535);
16799       var $9789=(($9783+($9788<<2))|0);
16800       var $9790=$9789;
16801       var $9791=$9790;
16802       var $9792=HEAPF32[(($9791)>>2)];
16803       var $9793=$2;
16804       var $9794=(($9793+64)|0);
16805       var $9795=HEAP32[(($9794)>>2)];
16806       var $9796=$st;
16807       var $9797=(($9796+4)|0);
16808       var $9798=$9797;
16809       var $9799=HEAP16[(($9798)>>1)];
16810       var $9800=(($9799)&65535);
16811       var $9801=(($9795+($9800<<2))|0);
16812       var $9802=$9801;
16813       var $9803=$9802;
16814       var $9804=HEAPF32[(($9803)>>2)];
16815       var $9805=$9792 == $9804;
16816       var $9806=(($9805)&1);
16817       var $9807=(($9806)|0);
16818       var $9808=$2;
16819       var $9809=(($9808+64)|0);
16820       var $9810=HEAP32[(($9809)>>2)];
16821       var $9811=$st;
16822       var $9812=(($9811+6)|0);
16823       var $9813=$9812;
16824       var $9814=HEAP16[(($9813)>>1)];
16825       var $9815=(($9814)&65535);
16826       var $9816=(($9810+($9815<<2))|0);
16827       var $9817=$9816;
16828       var $9818=$9817;
16829       HEAPF32[(($9818)>>2)]=$9807;
16830       __label__ = 487; break;
16831     case 386:
16832       var $9820=$2;
16833       var $9821=(($9820+64)|0);
16834       var $9822=HEAP32[(($9821)>>2)];
16835       var $9823=$st;
16836       var $9824=(($9823+2)|0);
16837       var $9825=$9824;
16838       var $9826=HEAP16[(($9825)>>1)];
16839       var $9827=(($9826)&65535);
16840       var $9828=(($9822+($9827<<2))|0);
16841       var $9829=$9828;
16842       var $9830=$9829;
16843       var $9831=(($9830)|0);
16844       var $9832=HEAPF32[(($9831)>>2)];
16845       var $9833=$2;
16846       var $9834=(($9833+64)|0);
16847       var $9835=HEAP32[(($9834)>>2)];
16848       var $9836=$st;
16849       var $9837=(($9836+4)|0);
16850       var $9838=$9837;
16851       var $9839=HEAP16[(($9838)>>1)];
16852       var $9840=(($9839)&65535);
16853       var $9841=(($9835+($9840<<2))|0);
16854       var $9842=$9841;
16855       var $9843=$9842;
16856       var $9844=(($9843)|0);
16857       var $9845=HEAPF32[(($9844)>>2)];
16858       var $9846=$9832 == $9845;
16859       if ($9846) { __label__ = 387; break; } else { var $9904 = 0;__label__ = 389; break; }
16860     case 387:
16861       var $9848=$2;
16862       var $9849=(($9848+64)|0);
16863       var $9850=HEAP32[(($9849)>>2)];
16864       var $9851=$st;
16865       var $9852=(($9851+2)|0);
16866       var $9853=$9852;
16867       var $9854=HEAP16[(($9853)>>1)];
16868       var $9855=(($9854)&65535);
16869       var $9856=(($9850+($9855<<2))|0);
16870       var $9857=$9856;
16871       var $9858=$9857;
16872       var $9859=(($9858+4)|0);
16873       var $9860=HEAPF32[(($9859)>>2)];
16874       var $9861=$2;
16875       var $9862=(($9861+64)|0);
16876       var $9863=HEAP32[(($9862)>>2)];
16877       var $9864=$st;
16878       var $9865=(($9864+4)|0);
16879       var $9866=$9865;
16880       var $9867=HEAP16[(($9866)>>1)];
16881       var $9868=(($9867)&65535);
16882       var $9869=(($9863+($9868<<2))|0);
16883       var $9870=$9869;
16884       var $9871=$9870;
16885       var $9872=(($9871+4)|0);
16886       var $9873=HEAPF32[(($9872)>>2)];
16887       var $9874=$9860 == $9873;
16888       if ($9874) { __label__ = 388; break; } else { var $9904 = 0;__label__ = 389; break; }
16889     case 388:
16890       var $9876=$2;
16891       var $9877=(($9876+64)|0);
16892       var $9878=HEAP32[(($9877)>>2)];
16893       var $9879=$st;
16894       var $9880=(($9879+2)|0);
16895       var $9881=$9880;
16896       var $9882=HEAP16[(($9881)>>1)];
16897       var $9883=(($9882)&65535);
16898       var $9884=(($9878+($9883<<2))|0);
16899       var $9885=$9884;
16900       var $9886=$9885;
16901       var $9887=(($9886+8)|0);
16902       var $9888=HEAPF32[(($9887)>>2)];
16903       var $9889=$2;
16904       var $9890=(($9889+64)|0);
16905       var $9891=HEAP32[(($9890)>>2)];
16906       var $9892=$st;
16907       var $9893=(($9892+4)|0);
16908       var $9894=$9893;
16909       var $9895=HEAP16[(($9894)>>1)];
16910       var $9896=(($9895)&65535);
16911       var $9897=(($9891+($9896<<2))|0);
16912       var $9898=$9897;
16913       var $9899=$9898;
16914       var $9900=(($9899+8)|0);
16915       var $9901=HEAPF32[(($9900)>>2)];
16916       var $9902=$9888 == $9901;
16917       var $9904 = $9902;__label__ = 389; break;
16918     case 389:
16919       var $9904;
16920       var $9905=(($9904)&1);
16921       var $9906=(($9905)|0);
16922       var $9907=$2;
16923       var $9908=(($9907+64)|0);
16924       var $9909=HEAP32[(($9908)>>2)];
16925       var $9910=$st;
16926       var $9911=(($9910+6)|0);
16927       var $9912=$9911;
16928       var $9913=HEAP16[(($9912)>>1)];
16929       var $9914=(($9913)&65535);
16930       var $9915=(($9909+($9914<<2))|0);
16931       var $9916=$9915;
16932       var $9917=$9916;
16933       HEAPF32[(($9917)>>2)]=$9906;
16934       __label__ = 487; break;
16935     case 390:
16936       var $9919=$2;
16937       var $9920=$2;
16938       var $9921=(($9920+64)|0);
16939       var $9922=HEAP32[(($9921)>>2)];
16940       var $9923=$st;
16941       var $9924=(($9923+2)|0);
16942       var $9925=$9924;
16943       var $9926=HEAP16[(($9925)>>1)];
16944       var $9927=(($9926)&65535);
16945       var $9928=(($9922+($9927<<2))|0);
16946       var $9929=$9928;
16947       var $9930=$9929;
16948       var $9931=HEAP32[(($9930)>>2)];
16949       var $9932=_prog_getstring($9919, $9931);
16950       var $9933=$2;
16951       var $9934=$2;
16952       var $9935=(($9934+64)|0);
16953       var $9936=HEAP32[(($9935)>>2)];
16954       var $9937=$st;
16955       var $9938=(($9937+4)|0);
16956       var $9939=$9938;
16957       var $9940=HEAP16[(($9939)>>1)];
16958       var $9941=(($9940)&65535);
16959       var $9942=(($9936+($9941<<2))|0);
16960       var $9943=$9942;
16961       var $9944=$9943;
16962       var $9945=HEAP32[(($9944)>>2)];
16963       var $9946=_prog_getstring($9933, $9945);
16964       var $9947=_strcmp($9932, $9946);
16965       var $9948=(($9947)|0)!=0;
16966       var $9949=$9948 ^ 1;
16967       var $9950=(($9949)&1);
16968       var $9951=(($9950)|0);
16969       var $9952=$2;
16970       var $9953=(($9952+64)|0);
16971       var $9954=HEAP32[(($9953)>>2)];
16972       var $9955=$st;
16973       var $9956=(($9955+6)|0);
16974       var $9957=$9956;
16975       var $9958=HEAP16[(($9957)>>1)];
16976       var $9959=(($9958)&65535);
16977       var $9960=(($9954+($9959<<2))|0);
16978       var $9961=$9960;
16979       var $9962=$9961;
16980       HEAPF32[(($9962)>>2)]=$9951;
16981       __label__ = 487; break;
16982     case 391:
16983       var $9964=$2;
16984       var $9965=(($9964+64)|0);
16985       var $9966=HEAP32[(($9965)>>2)];
16986       var $9967=$st;
16987       var $9968=(($9967+2)|0);
16988       var $9969=$9968;
16989       var $9970=HEAP16[(($9969)>>1)];
16990       var $9971=(($9970)&65535);
16991       var $9972=(($9966+($9971<<2))|0);
16992       var $9973=$9972;
16993       var $9974=$9973;
16994       var $9975=HEAP32[(($9974)>>2)];
16995       var $9976=$2;
16996       var $9977=(($9976+64)|0);
16997       var $9978=HEAP32[(($9977)>>2)];
16998       var $9979=$st;
16999       var $9980=(($9979+4)|0);
17000       var $9981=$9980;
17001       var $9982=HEAP16[(($9981)>>1)];
17002       var $9983=(($9982)&65535);
17003       var $9984=(($9978+($9983<<2))|0);
17004       var $9985=$9984;
17005       var $9986=$9985;
17006       var $9987=HEAP32[(($9986)>>2)];
17007       var $9988=(($9975)|0)==(($9987)|0);
17008       var $9989=(($9988)&1);
17009       var $9990=(($9989)|0);
17010       var $9991=$2;
17011       var $9992=(($9991+64)|0);
17012       var $9993=HEAP32[(($9992)>>2)];
17013       var $9994=$st;
17014       var $9995=(($9994+6)|0);
17015       var $9996=$9995;
17016       var $9997=HEAP16[(($9996)>>1)];
17017       var $9998=(($9997)&65535);
17018       var $9999=(($9993+($9998<<2))|0);
17019       var $10000=$9999;
17020       var $10001=$10000;
17021       HEAPF32[(($10001)>>2)]=$9990;
17022       __label__ = 487; break;
17023     case 392:
17024       var $10003=$2;
17025       var $10004=(($10003+64)|0);
17026       var $10005=HEAP32[(($10004)>>2)];
17027       var $10006=$st;
17028       var $10007=(($10006+2)|0);
17029       var $10008=$10007;
17030       var $10009=HEAP16[(($10008)>>1)];
17031       var $10010=(($10009)&65535);
17032       var $10011=(($10005+($10010<<2))|0);
17033       var $10012=$10011;
17034       var $10013=$10012;
17035       var $10014=HEAP32[(($10013)>>2)];
17036       var $10015=$2;
17037       var $10016=(($10015+64)|0);
17038       var $10017=HEAP32[(($10016)>>2)];
17039       var $10018=$st;
17040       var $10019=(($10018+4)|0);
17041       var $10020=$10019;
17042       var $10021=HEAP16[(($10020)>>1)];
17043       var $10022=(($10021)&65535);
17044       var $10023=(($10017+($10022<<2))|0);
17045       var $10024=$10023;
17046       var $10025=$10024;
17047       var $10026=HEAP32[(($10025)>>2)];
17048       var $10027=(($10014)|0)==(($10026)|0);
17049       var $10028=(($10027)&1);
17050       var $10029=(($10028)|0);
17051       var $10030=$2;
17052       var $10031=(($10030+64)|0);
17053       var $10032=HEAP32[(($10031)>>2)];
17054       var $10033=$st;
17055       var $10034=(($10033+6)|0);
17056       var $10035=$10034;
17057       var $10036=HEAP16[(($10035)>>1)];
17058       var $10037=(($10036)&65535);
17059       var $10038=(($10032+($10037<<2))|0);
17060       var $10039=$10038;
17061       var $10040=$10039;
17062       HEAPF32[(($10040)>>2)]=$10029;
17063       __label__ = 487; break;
17064     case 393:
17065       var $10042=$2;
17066       var $10043=(($10042+64)|0);
17067       var $10044=HEAP32[(($10043)>>2)];
17068       var $10045=$st;
17069       var $10046=(($10045+2)|0);
17070       var $10047=$10046;
17071       var $10048=HEAP16[(($10047)>>1)];
17072       var $10049=(($10048)&65535);
17073       var $10050=(($10044+($10049<<2))|0);
17074       var $10051=$10050;
17075       var $10052=$10051;
17076       var $10053=HEAPF32[(($10052)>>2)];
17077       var $10054=$2;
17078       var $10055=(($10054+64)|0);
17079       var $10056=HEAP32[(($10055)>>2)];
17080       var $10057=$st;
17081       var $10058=(($10057+4)|0);
17082       var $10059=$10058;
17083       var $10060=HEAP16[(($10059)>>1)];
17084       var $10061=(($10060)&65535);
17085       var $10062=(($10056+($10061<<2))|0);
17086       var $10063=$10062;
17087       var $10064=$10063;
17088       var $10065=HEAPF32[(($10064)>>2)];
17089       var $10066=$10053 != $10065;
17090       var $10067=(($10066)&1);
17091       var $10068=(($10067)|0);
17092       var $10069=$2;
17093       var $10070=(($10069+64)|0);
17094       var $10071=HEAP32[(($10070)>>2)];
17095       var $10072=$st;
17096       var $10073=(($10072+6)|0);
17097       var $10074=$10073;
17098       var $10075=HEAP16[(($10074)>>1)];
17099       var $10076=(($10075)&65535);
17100       var $10077=(($10071+($10076<<2))|0);
17101       var $10078=$10077;
17102       var $10079=$10078;
17103       HEAPF32[(($10079)>>2)]=$10068;
17104       __label__ = 487; break;
17105     case 394:
17106       var $10081=$2;
17107       var $10082=(($10081+64)|0);
17108       var $10083=HEAP32[(($10082)>>2)];
17109       var $10084=$st;
17110       var $10085=(($10084+2)|0);
17111       var $10086=$10085;
17112       var $10087=HEAP16[(($10086)>>1)];
17113       var $10088=(($10087)&65535);
17114       var $10089=(($10083+($10088<<2))|0);
17115       var $10090=$10089;
17116       var $10091=$10090;
17117       var $10092=(($10091)|0);
17118       var $10093=HEAPF32[(($10092)>>2)];
17119       var $10094=$2;
17120       var $10095=(($10094+64)|0);
17121       var $10096=HEAP32[(($10095)>>2)];
17122       var $10097=$st;
17123       var $10098=(($10097+4)|0);
17124       var $10099=$10098;
17125       var $10100=HEAP16[(($10099)>>1)];
17126       var $10101=(($10100)&65535);
17127       var $10102=(($10096+($10101<<2))|0);
17128       var $10103=$10102;
17129       var $10104=$10103;
17130       var $10105=(($10104)|0);
17131       var $10106=HEAPF32[(($10105)>>2)];
17132       var $10107=$10093 != $10106;
17133       if ($10107) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 395; break; }
17134     case 395:
17135       var $10109=$2;
17136       var $10110=(($10109+64)|0);
17137       var $10111=HEAP32[(($10110)>>2)];
17138       var $10112=$st;
17139       var $10113=(($10112+2)|0);
17140       var $10114=$10113;
17141       var $10115=HEAP16[(($10114)>>1)];
17142       var $10116=(($10115)&65535);
17143       var $10117=(($10111+($10116<<2))|0);
17144       var $10118=$10117;
17145       var $10119=$10118;
17146       var $10120=(($10119+4)|0);
17147       var $10121=HEAPF32[(($10120)>>2)];
17148       var $10122=$2;
17149       var $10123=(($10122+64)|0);
17150       var $10124=HEAP32[(($10123)>>2)];
17151       var $10125=$st;
17152       var $10126=(($10125+4)|0);
17153       var $10127=$10126;
17154       var $10128=HEAP16[(($10127)>>1)];
17155       var $10129=(($10128)&65535);
17156       var $10130=(($10124+($10129<<2))|0);
17157       var $10131=$10130;
17158       var $10132=$10131;
17159       var $10133=(($10132+4)|0);
17160       var $10134=HEAPF32[(($10133)>>2)];
17161       var $10135=$10121 != $10134;
17162       if ($10135) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 396; break; }
17163     case 396:
17164       var $10137=$2;
17165       var $10138=(($10137+64)|0);
17166       var $10139=HEAP32[(($10138)>>2)];
17167       var $10140=$st;
17168       var $10141=(($10140+2)|0);
17169       var $10142=$10141;
17170       var $10143=HEAP16[(($10142)>>1)];
17171       var $10144=(($10143)&65535);
17172       var $10145=(($10139+($10144<<2))|0);
17173       var $10146=$10145;
17174       var $10147=$10146;
17175       var $10148=(($10147+8)|0);
17176       var $10149=HEAPF32[(($10148)>>2)];
17177       var $10150=$2;
17178       var $10151=(($10150+64)|0);
17179       var $10152=HEAP32[(($10151)>>2)];
17180       var $10153=$st;
17181       var $10154=(($10153+4)|0);
17182       var $10155=$10154;
17183       var $10156=HEAP16[(($10155)>>1)];
17184       var $10157=(($10156)&65535);
17185       var $10158=(($10152+($10157<<2))|0);
17186       var $10159=$10158;
17187       var $10160=$10159;
17188       var $10161=(($10160+8)|0);
17189       var $10162=HEAPF32[(($10161)>>2)];
17190       var $10163=$10149 != $10162;
17191       var $10165 = $10163;__label__ = 397; break;
17192     case 397:
17193       var $10165;
17194       var $10166=(($10165)&1);
17195       var $10167=(($10166)|0);
17196       var $10168=$2;
17197       var $10169=(($10168+64)|0);
17198       var $10170=HEAP32[(($10169)>>2)];
17199       var $10171=$st;
17200       var $10172=(($10171+6)|0);
17201       var $10173=$10172;
17202       var $10174=HEAP16[(($10173)>>1)];
17203       var $10175=(($10174)&65535);
17204       var $10176=(($10170+($10175<<2))|0);
17205       var $10177=$10176;
17206       var $10178=$10177;
17207       HEAPF32[(($10178)>>2)]=$10167;
17208       __label__ = 487; break;
17209     case 398:
17210       var $10180=$2;
17211       var $10181=$2;
17212       var $10182=(($10181+64)|0);
17213       var $10183=HEAP32[(($10182)>>2)];
17214       var $10184=$st;
17215       var $10185=(($10184+2)|0);
17216       var $10186=$10185;
17217       var $10187=HEAP16[(($10186)>>1)];
17218       var $10188=(($10187)&65535);
17219       var $10189=(($10183+($10188<<2))|0);
17220       var $10190=$10189;
17221       var $10191=$10190;
17222       var $10192=HEAP32[(($10191)>>2)];
17223       var $10193=_prog_getstring($10180, $10192);
17224       var $10194=$2;
17225       var $10195=$2;
17226       var $10196=(($10195+64)|0);
17227       var $10197=HEAP32[(($10196)>>2)];
17228       var $10198=$st;
17229       var $10199=(($10198+4)|0);
17230       var $10200=$10199;
17231       var $10201=HEAP16[(($10200)>>1)];
17232       var $10202=(($10201)&65535);
17233       var $10203=(($10197+($10202<<2))|0);
17234       var $10204=$10203;
17235       var $10205=$10204;
17236       var $10206=HEAP32[(($10205)>>2)];
17237       var $10207=_prog_getstring($10194, $10206);
17238       var $10208=_strcmp($10193, $10207);
17239       var $10209=(($10208)|0)!=0;
17240       var $10210=$10209 ^ 1;
17241       var $10211=$10210 ^ 1;
17242       var $10212=(($10211)&1);
17243       var $10213=(($10212)|0);
17244       var $10214=$2;
17245       var $10215=(($10214+64)|0);
17246       var $10216=HEAP32[(($10215)>>2)];
17247       var $10217=$st;
17248       var $10218=(($10217+6)|0);
17249       var $10219=$10218;
17250       var $10220=HEAP16[(($10219)>>1)];
17251       var $10221=(($10220)&65535);
17252       var $10222=(($10216+($10221<<2))|0);
17253       var $10223=$10222;
17254       var $10224=$10223;
17255       HEAPF32[(($10224)>>2)]=$10213;
17256       __label__ = 487; break;
17257     case 399:
17258       var $10226=$2;
17259       var $10227=(($10226+64)|0);
17260       var $10228=HEAP32[(($10227)>>2)];
17261       var $10229=$st;
17262       var $10230=(($10229+2)|0);
17263       var $10231=$10230;
17264       var $10232=HEAP16[(($10231)>>1)];
17265       var $10233=(($10232)&65535);
17266       var $10234=(($10228+($10233<<2))|0);
17267       var $10235=$10234;
17268       var $10236=$10235;
17269       var $10237=HEAP32[(($10236)>>2)];
17270       var $10238=$2;
17271       var $10239=(($10238+64)|0);
17272       var $10240=HEAP32[(($10239)>>2)];
17273       var $10241=$st;
17274       var $10242=(($10241+4)|0);
17275       var $10243=$10242;
17276       var $10244=HEAP16[(($10243)>>1)];
17277       var $10245=(($10244)&65535);
17278       var $10246=(($10240+($10245<<2))|0);
17279       var $10247=$10246;
17280       var $10248=$10247;
17281       var $10249=HEAP32[(($10248)>>2)];
17282       var $10250=(($10237)|0)!=(($10249)|0);
17283       var $10251=(($10250)&1);
17284       var $10252=(($10251)|0);
17285       var $10253=$2;
17286       var $10254=(($10253+64)|0);
17287       var $10255=HEAP32[(($10254)>>2)];
17288       var $10256=$st;
17289       var $10257=(($10256+6)|0);
17290       var $10258=$10257;
17291       var $10259=HEAP16[(($10258)>>1)];
17292       var $10260=(($10259)&65535);
17293       var $10261=(($10255+($10260<<2))|0);
17294       var $10262=$10261;
17295       var $10263=$10262;
17296       HEAPF32[(($10263)>>2)]=$10252;
17297       __label__ = 487; break;
17298     case 400:
17299       var $10265=$2;
17300       var $10266=(($10265+64)|0);
17301       var $10267=HEAP32[(($10266)>>2)];
17302       var $10268=$st;
17303       var $10269=(($10268+2)|0);
17304       var $10270=$10269;
17305       var $10271=HEAP16[(($10270)>>1)];
17306       var $10272=(($10271)&65535);
17307       var $10273=(($10267+($10272<<2))|0);
17308       var $10274=$10273;
17309       var $10275=$10274;
17310       var $10276=HEAP32[(($10275)>>2)];
17311       var $10277=$2;
17312       var $10278=(($10277+64)|0);
17313       var $10279=HEAP32[(($10278)>>2)];
17314       var $10280=$st;
17315       var $10281=(($10280+4)|0);
17316       var $10282=$10281;
17317       var $10283=HEAP16[(($10282)>>1)];
17318       var $10284=(($10283)&65535);
17319       var $10285=(($10279+($10284<<2))|0);
17320       var $10286=$10285;
17321       var $10287=$10286;
17322       var $10288=HEAP32[(($10287)>>2)];
17323       var $10289=(($10276)|0)!=(($10288)|0);
17324       var $10290=(($10289)&1);
17325       var $10291=(($10290)|0);
17326       var $10292=$2;
17327       var $10293=(($10292+64)|0);
17328       var $10294=HEAP32[(($10293)>>2)];
17329       var $10295=$st;
17330       var $10296=(($10295+6)|0);
17331       var $10297=$10296;
17332       var $10298=HEAP16[(($10297)>>1)];
17333       var $10299=(($10298)&65535);
17334       var $10300=(($10294+($10299<<2))|0);
17335       var $10301=$10300;
17336       var $10302=$10301;
17337       HEAPF32[(($10302)>>2)]=$10291;
17338       __label__ = 487; break;
17339     case 401:
17340       var $10304=$2;
17341       var $10305=(($10304+64)|0);
17342       var $10306=HEAP32[(($10305)>>2)];
17343       var $10307=$st;
17344       var $10308=(($10307+2)|0);
17345       var $10309=$10308;
17346       var $10310=HEAP16[(($10309)>>1)];
17347       var $10311=(($10310)&65535);
17348       var $10312=(($10306+($10311<<2))|0);
17349       var $10313=$10312;
17350       var $10314=$10313;
17351       var $10315=HEAPF32[(($10314)>>2)];
17352       var $10316=$2;
17353       var $10317=(($10316+64)|0);
17354       var $10318=HEAP32[(($10317)>>2)];
17355       var $10319=$st;
17356       var $10320=(($10319+4)|0);
17357       var $10321=$10320;
17358       var $10322=HEAP16[(($10321)>>1)];
17359       var $10323=(($10322)&65535);
17360       var $10324=(($10318+($10323<<2))|0);
17361       var $10325=$10324;
17362       var $10326=$10325;
17363       var $10327=HEAPF32[(($10326)>>2)];
17364       var $10328=$10315 <= $10327;
17365       var $10329=(($10328)&1);
17366       var $10330=(($10329)|0);
17367       var $10331=$2;
17368       var $10332=(($10331+64)|0);
17369       var $10333=HEAP32[(($10332)>>2)];
17370       var $10334=$st;
17371       var $10335=(($10334+6)|0);
17372       var $10336=$10335;
17373       var $10337=HEAP16[(($10336)>>1)];
17374       var $10338=(($10337)&65535);
17375       var $10339=(($10333+($10338<<2))|0);
17376       var $10340=$10339;
17377       var $10341=$10340;
17378       HEAPF32[(($10341)>>2)]=$10330;
17379       __label__ = 487; break;
17380     case 402:
17381       var $10343=$2;
17382       var $10344=(($10343+64)|0);
17383       var $10345=HEAP32[(($10344)>>2)];
17384       var $10346=$st;
17385       var $10347=(($10346+2)|0);
17386       var $10348=$10347;
17387       var $10349=HEAP16[(($10348)>>1)];
17388       var $10350=(($10349)&65535);
17389       var $10351=(($10345+($10350<<2))|0);
17390       var $10352=$10351;
17391       var $10353=$10352;
17392       var $10354=HEAPF32[(($10353)>>2)];
17393       var $10355=$2;
17394       var $10356=(($10355+64)|0);
17395       var $10357=HEAP32[(($10356)>>2)];
17396       var $10358=$st;
17397       var $10359=(($10358+4)|0);
17398       var $10360=$10359;
17399       var $10361=HEAP16[(($10360)>>1)];
17400       var $10362=(($10361)&65535);
17401       var $10363=(($10357+($10362<<2))|0);
17402       var $10364=$10363;
17403       var $10365=$10364;
17404       var $10366=HEAPF32[(($10365)>>2)];
17405       var $10367=$10354 >= $10366;
17406       var $10368=(($10367)&1);
17407       var $10369=(($10368)|0);
17408       var $10370=$2;
17409       var $10371=(($10370+64)|0);
17410       var $10372=HEAP32[(($10371)>>2)];
17411       var $10373=$st;
17412       var $10374=(($10373+6)|0);
17413       var $10375=$10374;
17414       var $10376=HEAP16[(($10375)>>1)];
17415       var $10377=(($10376)&65535);
17416       var $10378=(($10372+($10377<<2))|0);
17417       var $10379=$10378;
17418       var $10380=$10379;
17419       HEAPF32[(($10380)>>2)]=$10369;
17420       __label__ = 487; break;
17421     case 403:
17422       var $10382=$2;
17423       var $10383=(($10382+64)|0);
17424       var $10384=HEAP32[(($10383)>>2)];
17425       var $10385=$st;
17426       var $10386=(($10385+2)|0);
17427       var $10387=$10386;
17428       var $10388=HEAP16[(($10387)>>1)];
17429       var $10389=(($10388)&65535);
17430       var $10390=(($10384+($10389<<2))|0);
17431       var $10391=$10390;
17432       var $10392=$10391;
17433       var $10393=HEAPF32[(($10392)>>2)];
17434       var $10394=$2;
17435       var $10395=(($10394+64)|0);
17436       var $10396=HEAP32[(($10395)>>2)];
17437       var $10397=$st;
17438       var $10398=(($10397+4)|0);
17439       var $10399=$10398;
17440       var $10400=HEAP16[(($10399)>>1)];
17441       var $10401=(($10400)&65535);
17442       var $10402=(($10396+($10401<<2))|0);
17443       var $10403=$10402;
17444       var $10404=$10403;
17445       var $10405=HEAPF32[(($10404)>>2)];
17446       var $10406=$10393 < $10405;
17447       var $10407=(($10406)&1);
17448       var $10408=(($10407)|0);
17449       var $10409=$2;
17450       var $10410=(($10409+64)|0);
17451       var $10411=HEAP32[(($10410)>>2)];
17452       var $10412=$st;
17453       var $10413=(($10412+6)|0);
17454       var $10414=$10413;
17455       var $10415=HEAP16[(($10414)>>1)];
17456       var $10416=(($10415)&65535);
17457       var $10417=(($10411+($10416<<2))|0);
17458       var $10418=$10417;
17459       var $10419=$10418;
17460       HEAPF32[(($10419)>>2)]=$10408;
17461       __label__ = 487; break;
17462     case 404:
17463       var $10421=$2;
17464       var $10422=(($10421+64)|0);
17465       var $10423=HEAP32[(($10422)>>2)];
17466       var $10424=$st;
17467       var $10425=(($10424+2)|0);
17468       var $10426=$10425;
17469       var $10427=HEAP16[(($10426)>>1)];
17470       var $10428=(($10427)&65535);
17471       var $10429=(($10423+($10428<<2))|0);
17472       var $10430=$10429;
17473       var $10431=$10430;
17474       var $10432=HEAPF32[(($10431)>>2)];
17475       var $10433=$2;
17476       var $10434=(($10433+64)|0);
17477       var $10435=HEAP32[(($10434)>>2)];
17478       var $10436=$st;
17479       var $10437=(($10436+4)|0);
17480       var $10438=$10437;
17481       var $10439=HEAP16[(($10438)>>1)];
17482       var $10440=(($10439)&65535);
17483       var $10441=(($10435+($10440<<2))|0);
17484       var $10442=$10441;
17485       var $10443=$10442;
17486       var $10444=HEAPF32[(($10443)>>2)];
17487       var $10445=$10432 > $10444;
17488       var $10446=(($10445)&1);
17489       var $10447=(($10446)|0);
17490       var $10448=$2;
17491       var $10449=(($10448+64)|0);
17492       var $10450=HEAP32[(($10449)>>2)];
17493       var $10451=$st;
17494       var $10452=(($10451+6)|0);
17495       var $10453=$10452;
17496       var $10454=HEAP16[(($10453)>>1)];
17497       var $10455=(($10454)&65535);
17498       var $10456=(($10450+($10455<<2))|0);
17499       var $10457=$10456;
17500       var $10458=$10457;
17501       HEAPF32[(($10458)>>2)]=$10447;
17502       __label__ = 487; break;
17503     case 405:
17504       var $10460=$2;
17505       var $10461=(($10460+64)|0);
17506       var $10462=HEAP32[(($10461)>>2)];
17507       var $10463=$st;
17508       var $10464=(($10463+2)|0);
17509       var $10465=$10464;
17510       var $10466=HEAP16[(($10465)>>1)];
17511       var $10467=(($10466)&65535);
17512       var $10468=(($10462+($10467<<2))|0);
17513       var $10469=$10468;
17514       var $10470=$10469;
17515       var $10471=HEAP32[(($10470)>>2)];
17516       var $10472=(($10471)|0) < 0;
17517       if ($10472) { __label__ = 407; break; } else { __label__ = 406; break; }
17518     case 406:
17519       var $10474=$2;
17520       var $10475=(($10474+64)|0);
17521       var $10476=HEAP32[(($10475)>>2)];
17522       var $10477=$st;
17523       var $10478=(($10477+2)|0);
17524       var $10479=$10478;
17525       var $10480=HEAP16[(($10479)>>1)];
17526       var $10481=(($10480)&65535);
17527       var $10482=(($10476+($10481<<2))|0);
17528       var $10483=$10482;
17529       var $10484=$10483;
17530       var $10485=HEAP32[(($10484)>>2)];
17531       var $10486=$2;
17532       var $10487=(($10486+140)|0);
17533       var $10488=HEAP32[(($10487)>>2)];
17534       var $10489=(($10485)|0) >= (($10488)|0);
17535       if ($10489) { __label__ = 407; break; } else { __label__ = 408; break; }
17536     case 407:
17537       var $10491=$2;
17538       var $10492=$2;
17539       var $10493=(($10492)|0);
17540       var $10494=HEAP32[(($10493)>>2)];
17541       _qcvmerror($10491, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10494,tempInt));
17542       __label__ = 488; break;
17543     case 408:
17544       var $10496=$2;
17545       var $10497=(($10496+64)|0);
17546       var $10498=HEAP32[(($10497)>>2)];
17547       var $10499=$st;
17548       var $10500=(($10499+4)|0);
17549       var $10501=$10500;
17550       var $10502=HEAP16[(($10501)>>1)];
17551       var $10503=(($10502)&65535);
17552       var $10504=(($10498+($10503<<2))|0);
17553       var $10505=$10504;
17554       var $10506=$10505;
17555       var $10507=HEAP32[(($10506)>>2)];
17556       var $10508=$2;
17557       var $10509=(($10508+144)|0);
17558       var $10510=HEAP32[(($10509)>>2)];
17559       var $10511=(($10507)>>>0) >= (($10510)>>>0);
17560       if ($10511) { __label__ = 409; break; } else { __label__ = 410; break; }
17561     case 409:
17562       var $10513=$2;
17563       var $10514=$2;
17564       var $10515=(($10514)|0);
17565       var $10516=HEAP32[(($10515)>>2)];
17566       var $10517=$2;
17567       var $10518=(($10517+64)|0);
17568       var $10519=HEAP32[(($10518)>>2)];
17569       var $10520=$st;
17570       var $10521=(($10520+4)|0);
17571       var $10522=$10521;
17572       var $10523=HEAP16[(($10522)>>1)];
17573       var $10524=(($10523)&65535);
17574       var $10525=(($10519+($10524<<2))|0);
17575       var $10526=$10525;
17576       var $10527=$10526;
17577       var $10528=HEAP32[(($10527)>>2)];
17578       _qcvmerror($10513, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10516,HEAP32[(((tempInt)+(4))>>2)]=$10528,tempInt));
17579       __label__ = 488; break;
17580     case 410:
17581       var $10530=$2;
17582       var $10531=$2;
17583       var $10532=(($10531+64)|0);
17584       var $10533=HEAP32[(($10532)>>2)];
17585       var $10534=$st;
17586       var $10535=(($10534+2)|0);
17587       var $10536=$10535;
17588       var $10537=HEAP16[(($10536)>>1)];
17589       var $10538=(($10537)&65535);
17590       var $10539=(($10533+($10538<<2))|0);
17591       var $10540=$10539;
17592       var $10541=$10540;
17593       var $10542=HEAP32[(($10541)>>2)];
17594       var $10543=_prog_getedict($10530, $10542);
17595       $ed10=$10543;
17596       var $10544=$ed10;
17597       var $10545=$10544;
17598       var $10546=$2;
17599       var $10547=(($10546+64)|0);
17600       var $10548=HEAP32[(($10547)>>2)];
17601       var $10549=$st;
17602       var $10550=(($10549+4)|0);
17603       var $10551=$10550;
17604       var $10552=HEAP16[(($10551)>>1)];
17605       var $10553=(($10552)&65535);
17606       var $10554=(($10548+($10553<<2))|0);
17607       var $10555=$10554;
17608       var $10556=$10555;
17609       var $10557=HEAP32[(($10556)>>2)];
17610       var $10558=(($10545+($10557<<2))|0);
17611       var $10559=$10558;
17612       var $10560=$10559;
17613       var $10561=HEAP32[(($10560)>>2)];
17614       var $10562=$2;
17615       var $10563=(($10562+64)|0);
17616       var $10564=HEAP32[(($10563)>>2)];
17617       var $10565=$st;
17618       var $10566=(($10565+6)|0);
17619       var $10567=$10566;
17620       var $10568=HEAP16[(($10567)>>1)];
17621       var $10569=(($10568)&65535);
17622       var $10570=(($10564+($10569<<2))|0);
17623       var $10571=$10570;
17624       var $10572=$10571;
17625       HEAP32[(($10572)>>2)]=$10561;
17626       __label__ = 487; break;
17627     case 411:
17628       var $10574=$2;
17629       var $10575=(($10574+64)|0);
17630       var $10576=HEAP32[(($10575)>>2)];
17631       var $10577=$st;
17632       var $10578=(($10577+2)|0);
17633       var $10579=$10578;
17634       var $10580=HEAP16[(($10579)>>1)];
17635       var $10581=(($10580)&65535);
17636       var $10582=(($10576+($10581<<2))|0);
17637       var $10583=$10582;
17638       var $10584=$10583;
17639       var $10585=HEAP32[(($10584)>>2)];
17640       var $10586=(($10585)|0) < 0;
17641       if ($10586) { __label__ = 413; break; } else { __label__ = 412; break; }
17642     case 412:
17643       var $10588=$2;
17644       var $10589=(($10588+64)|0);
17645       var $10590=HEAP32[(($10589)>>2)];
17646       var $10591=$st;
17647       var $10592=(($10591+2)|0);
17648       var $10593=$10592;
17649       var $10594=HEAP16[(($10593)>>1)];
17650       var $10595=(($10594)&65535);
17651       var $10596=(($10590+($10595<<2))|0);
17652       var $10597=$10596;
17653       var $10598=$10597;
17654       var $10599=HEAP32[(($10598)>>2)];
17655       var $10600=$2;
17656       var $10601=(($10600+140)|0);
17657       var $10602=HEAP32[(($10601)>>2)];
17658       var $10603=(($10599)|0) >= (($10602)|0);
17659       if ($10603) { __label__ = 413; break; } else { __label__ = 414; break; }
17660     case 413:
17661       var $10605=$2;
17662       var $10606=$2;
17663       var $10607=(($10606)|0);
17664       var $10608=HEAP32[(($10607)>>2)];
17665       _qcvmerror($10605, ((STRING_TABLE.__str17)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10608,tempInt));
17666       __label__ = 488; break;
17667     case 414:
17668       var $10610=$2;
17669       var $10611=(($10610+64)|0);
17670       var $10612=HEAP32[(($10611)>>2)];
17671       var $10613=$st;
17672       var $10614=(($10613+4)|0);
17673       var $10615=$10614;
17674       var $10616=HEAP16[(($10615)>>1)];
17675       var $10617=(($10616)&65535);
17676       var $10618=(($10612+($10617<<2))|0);
17677       var $10619=$10618;
17678       var $10620=$10619;
17679       var $10621=HEAP32[(($10620)>>2)];
17680       var $10622=(($10621)|0) < 0;
17681       if ($10622) { __label__ = 416; break; } else { __label__ = 415; break; }
17682     case 415:
17683       var $10624=$2;
17684       var $10625=(($10624+64)|0);
17685       var $10626=HEAP32[(($10625)>>2)];
17686       var $10627=$st;
17687       var $10628=(($10627+4)|0);
17688       var $10629=$10628;
17689       var $10630=HEAP16[(($10629)>>1)];
17690       var $10631=(($10630)&65535);
17691       var $10632=(($10626+($10631<<2))|0);
17692       var $10633=$10632;
17693       var $10634=$10633;
17694       var $10635=HEAP32[(($10634)>>2)];
17695       var $10636=((($10635)+(3))|0);
17696       var $10637=$2;
17697       var $10638=(($10637+144)|0);
17698       var $10639=HEAP32[(($10638)>>2)];
17699       var $10640=(($10636)>>>0) > (($10639)>>>0);
17700       if ($10640) { __label__ = 416; break; } else { __label__ = 417; break; }
17701     case 416:
17702       var $10642=$2;
17703       var $10643=$2;
17704       var $10644=(($10643)|0);
17705       var $10645=HEAP32[(($10644)>>2)];
17706       var $10646=$2;
17707       var $10647=(($10646+64)|0);
17708       var $10648=HEAP32[(($10647)>>2)];
17709       var $10649=$st;
17710       var $10650=(($10649+4)|0);
17711       var $10651=$10650;
17712       var $10652=HEAP16[(($10651)>>1)];
17713       var $10653=(($10652)&65535);
17714       var $10654=(($10648+($10653<<2))|0);
17715       var $10655=$10654;
17716       var $10656=$10655;
17717       var $10657=HEAP32[(($10656)>>2)];
17718       var $10658=((($10657)+(2))|0);
17719       _qcvmerror($10642, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10645,HEAP32[(((tempInt)+(4))>>2)]=$10658,tempInt));
17720       __label__ = 488; break;
17721     case 417:
17722       var $10660=$2;
17723       var $10661=$2;
17724       var $10662=(($10661+64)|0);
17725       var $10663=HEAP32[(($10662)>>2)];
17726       var $10664=$st;
17727       var $10665=(($10664+2)|0);
17728       var $10666=$10665;
17729       var $10667=HEAP16[(($10666)>>1)];
17730       var $10668=(($10667)&65535);
17731       var $10669=(($10663+($10668<<2))|0);
17732       var $10670=$10669;
17733       var $10671=$10670;
17734       var $10672=HEAP32[(($10671)>>2)];
17735       var $10673=_prog_getedict($10660, $10672);
17736       $ed10=$10673;
17737       var $10674=$ed10;
17738       var $10675=$10674;
17739       var $10676=$2;
17740       var $10677=(($10676+64)|0);
17741       var $10678=HEAP32[(($10677)>>2)];
17742       var $10679=$st;
17743       var $10680=(($10679+4)|0);
17744       var $10681=$10680;
17745       var $10682=HEAP16[(($10681)>>1)];
17746       var $10683=(($10682)&65535);
17747       var $10684=(($10678+($10683<<2))|0);
17748       var $10685=$10684;
17749       var $10686=$10685;
17750       var $10687=HEAP32[(($10686)>>2)];
17751       var $10688=(($10675+($10687<<2))|0);
17752       var $10689=$10688;
17753       var $10690=$10689;
17754       var $10691=(($10690)|0);
17755       var $10692=HEAP32[(($10691)>>2)];
17756       var $10693=$2;
17757       var $10694=(($10693+64)|0);
17758       var $10695=HEAP32[(($10694)>>2)];
17759       var $10696=$st;
17760       var $10697=(($10696+6)|0);
17761       var $10698=$10697;
17762       var $10699=HEAP16[(($10698)>>1)];
17763       var $10700=(($10699)&65535);
17764       var $10701=(($10695+($10700<<2))|0);
17765       var $10702=$10701;
17766       var $10703=$10702;
17767       var $10704=(($10703)|0);
17768       HEAP32[(($10704)>>2)]=$10692;
17769       var $10705=$ed10;
17770       var $10706=$10705;
17771       var $10707=$2;
17772       var $10708=(($10707+64)|0);
17773       var $10709=HEAP32[(($10708)>>2)];
17774       var $10710=$st;
17775       var $10711=(($10710+4)|0);
17776       var $10712=$10711;
17777       var $10713=HEAP16[(($10712)>>1)];
17778       var $10714=(($10713)&65535);
17779       var $10715=(($10709+($10714<<2))|0);
17780       var $10716=$10715;
17781       var $10717=$10716;
17782       var $10718=HEAP32[(($10717)>>2)];
17783       var $10719=(($10706+($10718<<2))|0);
17784       var $10720=$10719;
17785       var $10721=$10720;
17786       var $10722=(($10721+4)|0);
17787       var $10723=HEAP32[(($10722)>>2)];
17788       var $10724=$2;
17789       var $10725=(($10724+64)|0);
17790       var $10726=HEAP32[(($10725)>>2)];
17791       var $10727=$st;
17792       var $10728=(($10727+6)|0);
17793       var $10729=$10728;
17794       var $10730=HEAP16[(($10729)>>1)];
17795       var $10731=(($10730)&65535);
17796       var $10732=(($10726+($10731<<2))|0);
17797       var $10733=$10732;
17798       var $10734=$10733;
17799       var $10735=(($10734+4)|0);
17800       HEAP32[(($10735)>>2)]=$10723;
17801       var $10736=$ed10;
17802       var $10737=$10736;
17803       var $10738=$2;
17804       var $10739=(($10738+64)|0);
17805       var $10740=HEAP32[(($10739)>>2)];
17806       var $10741=$st;
17807       var $10742=(($10741+4)|0);
17808       var $10743=$10742;
17809       var $10744=HEAP16[(($10743)>>1)];
17810       var $10745=(($10744)&65535);
17811       var $10746=(($10740+($10745<<2))|0);
17812       var $10747=$10746;
17813       var $10748=$10747;
17814       var $10749=HEAP32[(($10748)>>2)];
17815       var $10750=(($10737+($10749<<2))|0);
17816       var $10751=$10750;
17817       var $10752=$10751;
17818       var $10753=(($10752+8)|0);
17819       var $10754=HEAP32[(($10753)>>2)];
17820       var $10755=$2;
17821       var $10756=(($10755+64)|0);
17822       var $10757=HEAP32[(($10756)>>2)];
17823       var $10758=$st;
17824       var $10759=(($10758+6)|0);
17825       var $10760=$10759;
17826       var $10761=HEAP16[(($10760)>>1)];
17827       var $10762=(($10761)&65535);
17828       var $10763=(($10757+($10762<<2))|0);
17829       var $10764=$10763;
17830       var $10765=$10764;
17831       var $10766=(($10765+8)|0);
17832       HEAP32[(($10766)>>2)]=$10754;
17833       __label__ = 487; break;
17834     case 418:
17835       var $10768=$2;
17836       var $10769=(($10768+64)|0);
17837       var $10770=HEAP32[(($10769)>>2)];
17838       var $10771=$st;
17839       var $10772=(($10771+2)|0);
17840       var $10773=$10772;
17841       var $10774=HEAP16[(($10773)>>1)];
17842       var $10775=(($10774)&65535);
17843       var $10776=(($10770+($10775<<2))|0);
17844       var $10777=$10776;
17845       var $10778=$10777;
17846       var $10779=HEAP32[(($10778)>>2)];
17847       var $10780=(($10779)|0) < 0;
17848       if ($10780) { __label__ = 420; break; } else { __label__ = 419; break; }
17849     case 419:
17850       var $10782=$2;
17851       var $10783=(($10782+64)|0);
17852       var $10784=HEAP32[(($10783)>>2)];
17853       var $10785=$st;
17854       var $10786=(($10785+2)|0);
17855       var $10787=$10786;
17856       var $10788=HEAP16[(($10787)>>1)];
17857       var $10789=(($10788)&65535);
17858       var $10790=(($10784+($10789<<2))|0);
17859       var $10791=$10790;
17860       var $10792=$10791;
17861       var $10793=HEAP32[(($10792)>>2)];
17862       var $10794=$2;
17863       var $10795=(($10794+140)|0);
17864       var $10796=HEAP32[(($10795)>>2)];
17865       var $10797=(($10793)|0) >= (($10796)|0);
17866       if ($10797) { __label__ = 420; break; } else { __label__ = 421; break; }
17867     case 420:
17868       var $10799=$2;
17869       var $10800=$2;
17870       var $10801=(($10800)|0);
17871       var $10802=HEAP32[(($10801)>>2)];
17872       var $10803=$2;
17873       var $10804=(($10803+64)|0);
17874       var $10805=HEAP32[(($10804)>>2)];
17875       var $10806=$st;
17876       var $10807=(($10806+2)|0);
17877       var $10808=$10807;
17878       var $10809=HEAP16[(($10808)>>1)];
17879       var $10810=(($10809)&65535);
17880       var $10811=(($10805+($10810<<2))|0);
17881       var $10812=$10811;
17882       var $10813=$10812;
17883       var $10814=HEAP32[(($10813)>>2)];
17884       _qcvmerror($10799, ((STRING_TABLE.__str19)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10802,HEAP32[(((tempInt)+(4))>>2)]=$10814,tempInt));
17885       __label__ = 488; break;
17886     case 421:
17887       var $10816=$2;
17888       var $10817=(($10816+64)|0);
17889       var $10818=HEAP32[(($10817)>>2)];
17890       var $10819=$st;
17891       var $10820=(($10819+4)|0);
17892       var $10821=$10820;
17893       var $10822=HEAP16[(($10821)>>1)];
17894       var $10823=(($10822)&65535);
17895       var $10824=(($10818+($10823<<2))|0);
17896       var $10825=$10824;
17897       var $10826=$10825;
17898       var $10827=HEAP32[(($10826)>>2)];
17899       var $10828=$2;
17900       var $10829=(($10828+144)|0);
17901       var $10830=HEAP32[(($10829)>>2)];
17902       var $10831=(($10827)>>>0) >= (($10830)>>>0);
17903       if ($10831) { __label__ = 422; break; } else { __label__ = 423; break; }
17904     case 422:
17905       var $10833=$2;
17906       var $10834=$2;
17907       var $10835=(($10834)|0);
17908       var $10836=HEAP32[(($10835)>>2)];
17909       var $10837=$2;
17910       var $10838=(($10837+64)|0);
17911       var $10839=HEAP32[(($10838)>>2)];
17912       var $10840=$st;
17913       var $10841=(($10840+4)|0);
17914       var $10842=$10841;
17915       var $10843=HEAP16[(($10842)>>1)];
17916       var $10844=(($10843)&65535);
17917       var $10845=(($10839+($10844<<2))|0);
17918       var $10846=$10845;
17919       var $10847=$10846;
17920       var $10848=HEAP32[(($10847)>>2)];
17921       _qcvmerror($10833, ((STRING_TABLE.__str18)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10836,HEAP32[(((tempInt)+(4))>>2)]=$10848,tempInt));
17922       __label__ = 488; break;
17923     case 423:
17924       var $10850=$2;
17925       var $10851=$2;
17926       var $10852=(($10851+64)|0);
17927       var $10853=HEAP32[(($10852)>>2)];
17928       var $10854=$st;
17929       var $10855=(($10854+2)|0);
17930       var $10856=$10855;
17931       var $10857=HEAP16[(($10856)>>1)];
17932       var $10858=(($10857)&65535);
17933       var $10859=(($10853+($10858<<2))|0);
17934       var $10860=$10859;
17935       var $10861=$10860;
17936       var $10862=HEAP32[(($10861)>>2)];
17937       var $10863=_prog_getedict($10850, $10862);
17938       $ed10=$10863;
17939       var $10864=$ed10;
17940       var $10865=$10864;
17941       var $10866=$2;
17942       var $10867=(($10866+76)|0);
17943       var $10868=HEAP32[(($10867)>>2)];
17944       var $10869=$10865;
17945       var $10870=$10868;
17946       var $10871=((($10869)-($10870))|0);
17947       var $10872=((((($10871)|0))/(4))&-1);
17948       var $10873=$2;
17949       var $10874=(($10873+64)|0);
17950       var $10875=HEAP32[(($10874)>>2)];
17951       var $10876=$st;
17952       var $10877=(($10876+6)|0);
17953       var $10878=$10877;
17954       var $10879=HEAP16[(($10878)>>1)];
17955       var $10880=(($10879)&65535);
17956       var $10881=(($10875+($10880<<2))|0);
17957       var $10882=$10881;
17958       var $10883=$10882;
17959       HEAP32[(($10883)>>2)]=$10872;
17960       var $10884=$2;
17961       var $10885=(($10884+64)|0);
17962       var $10886=HEAP32[(($10885)>>2)];
17963       var $10887=$st;
17964       var $10888=(($10887+4)|0);
17965       var $10889=$10888;
17966       var $10890=HEAP16[(($10889)>>1)];
17967       var $10891=(($10890)&65535);
17968       var $10892=(($10886+($10891<<2))|0);
17969       var $10893=$10892;
17970       var $10894=$10893;
17971       var $10895=HEAP32[(($10894)>>2)];
17972       var $10896=$2;
17973       var $10897=(($10896+64)|0);
17974       var $10898=HEAP32[(($10897)>>2)];
17975       var $10899=$st;
17976       var $10900=(($10899+6)|0);
17977       var $10901=$10900;
17978       var $10902=HEAP16[(($10901)>>1)];
17979       var $10903=(($10902)&65535);
17980       var $10904=(($10898+($10903<<2))|0);
17981       var $10905=$10904;
17982       var $10906=$10905;
17983       var $10907=HEAP32[(($10906)>>2)];
17984       var $10908=((($10907)+($10895))|0);
17985       HEAP32[(($10906)>>2)]=$10908;
17986       __label__ = 487; break;
17987     case 424:
17988       var $10910=$2;
17989       var $10911=(($10910+64)|0);
17990       var $10912=HEAP32[(($10911)>>2)];
17991       var $10913=$st;
17992       var $10914=(($10913+2)|0);
17993       var $10915=$10914;
17994       var $10916=HEAP16[(($10915)>>1)];
17995       var $10917=(($10916)&65535);
17996       var $10918=(($10912+($10917<<2))|0);
17997       var $10919=$10918;
17998       var $10920=$10919;
17999       var $10921=HEAP32[(($10920)>>2)];
18000       var $10922=$2;
18001       var $10923=(($10922+64)|0);
18002       var $10924=HEAP32[(($10923)>>2)];
18003       var $10925=$st;
18004       var $10926=(($10925+4)|0);
18005       var $10927=$10926;
18006       var $10928=HEAP16[(($10927)>>1)];
18007       var $10929=(($10928)&65535);
18008       var $10930=(($10924+($10929<<2))|0);
18009       var $10931=$10930;
18010       var $10932=$10931;
18011       HEAP32[(($10932)>>2)]=$10921;
18012       __label__ = 487; break;
18013     case 425:
18014       var $10934=$2;
18015       var $10935=(($10934+64)|0);
18016       var $10936=HEAP32[(($10935)>>2)];
18017       var $10937=$st;
18018       var $10938=(($10937+2)|0);
18019       var $10939=$10938;
18020       var $10940=HEAP16[(($10939)>>1)];
18021       var $10941=(($10940)&65535);
18022       var $10942=(($10936+($10941<<2))|0);
18023       var $10943=$10942;
18024       var $10944=$10943;
18025       var $10945=(($10944)|0);
18026       var $10946=HEAP32[(($10945)>>2)];
18027       var $10947=$2;
18028       var $10948=(($10947+64)|0);
18029       var $10949=HEAP32[(($10948)>>2)];
18030       var $10950=$st;
18031       var $10951=(($10950+4)|0);
18032       var $10952=$10951;
18033       var $10953=HEAP16[(($10952)>>1)];
18034       var $10954=(($10953)&65535);
18035       var $10955=(($10949+($10954<<2))|0);
18036       var $10956=$10955;
18037       var $10957=$10956;
18038       var $10958=(($10957)|0);
18039       HEAP32[(($10958)>>2)]=$10946;
18040       var $10959=$2;
18041       var $10960=(($10959+64)|0);
18042       var $10961=HEAP32[(($10960)>>2)];
18043       var $10962=$st;
18044       var $10963=(($10962+2)|0);
18045       var $10964=$10963;
18046       var $10965=HEAP16[(($10964)>>1)];
18047       var $10966=(($10965)&65535);
18048       var $10967=(($10961+($10966<<2))|0);
18049       var $10968=$10967;
18050       var $10969=$10968;
18051       var $10970=(($10969+4)|0);
18052       var $10971=HEAP32[(($10970)>>2)];
18053       var $10972=$2;
18054       var $10973=(($10972+64)|0);
18055       var $10974=HEAP32[(($10973)>>2)];
18056       var $10975=$st;
18057       var $10976=(($10975+4)|0);
18058       var $10977=$10976;
18059       var $10978=HEAP16[(($10977)>>1)];
18060       var $10979=(($10978)&65535);
18061       var $10980=(($10974+($10979<<2))|0);
18062       var $10981=$10980;
18063       var $10982=$10981;
18064       var $10983=(($10982+4)|0);
18065       HEAP32[(($10983)>>2)]=$10971;
18066       var $10984=$2;
18067       var $10985=(($10984+64)|0);
18068       var $10986=HEAP32[(($10985)>>2)];
18069       var $10987=$st;
18070       var $10988=(($10987+2)|0);
18071       var $10989=$10988;
18072       var $10990=HEAP16[(($10989)>>1)];
18073       var $10991=(($10990)&65535);
18074       var $10992=(($10986+($10991<<2))|0);
18075       var $10993=$10992;
18076       var $10994=$10993;
18077       var $10995=(($10994+8)|0);
18078       var $10996=HEAP32[(($10995)>>2)];
18079       var $10997=$2;
18080       var $10998=(($10997+64)|0);
18081       var $10999=HEAP32[(($10998)>>2)];
18082       var $11000=$st;
18083       var $11001=(($11000+4)|0);
18084       var $11002=$11001;
18085       var $11003=HEAP16[(($11002)>>1)];
18086       var $11004=(($11003)&65535);
18087       var $11005=(($10999+($11004<<2))|0);
18088       var $11006=$11005;
18089       var $11007=$11006;
18090       var $11008=(($11007+8)|0);
18091       HEAP32[(($11008)>>2)]=$10996;
18092       __label__ = 487; break;
18093     case 426:
18094       var $11010=$2;
18095       var $11011=(($11010+64)|0);
18096       var $11012=HEAP32[(($11011)>>2)];
18097       var $11013=$st;
18098       var $11014=(($11013+4)|0);
18099       var $11015=$11014;
18100       var $11016=HEAP16[(($11015)>>1)];
18101       var $11017=(($11016)&65535);
18102       var $11018=(($11012+($11017<<2))|0);
18103       var $11019=$11018;
18104       var $11020=$11019;
18105       var $11021=HEAP32[(($11020)>>2)];
18106       var $11022=(($11021)|0) < 0;
18107       if ($11022) { __label__ = 428; break; } else { __label__ = 427; break; }
18108     case 427:
18109       var $11024=$2;
18110       var $11025=(($11024+64)|0);
18111       var $11026=HEAP32[(($11025)>>2)];
18112       var $11027=$st;
18113       var $11028=(($11027+4)|0);
18114       var $11029=$11028;
18115       var $11030=HEAP16[(($11029)>>1)];
18116       var $11031=(($11030)&65535);
18117       var $11032=(($11026+($11031<<2))|0);
18118       var $11033=$11032;
18119       var $11034=$11033;
18120       var $11035=HEAP32[(($11034)>>2)];
18121       var $11036=$2;
18122       var $11037=(($11036+80)|0);
18123       var $11038=HEAP32[(($11037)>>2)];
18124       var $11039=(($11035)>>>0) >= (($11038)>>>0);
18125       if ($11039) { __label__ = 428; break; } else { __label__ = 429; break; }
18126     case 428:
18127       var $11041=$2;
18128       var $11042=$2;
18129       var $11043=(($11042)|0);
18130       var $11044=HEAP32[(($11043)>>2)];
18131       var $11045=$2;
18132       var $11046=(($11045+64)|0);
18133       var $11047=HEAP32[(($11046)>>2)];
18134       var $11048=$st;
18135       var $11049=(($11048+4)|0);
18136       var $11050=$11049;
18137       var $11051=HEAP16[(($11050)>>1)];
18138       var $11052=(($11051)&65535);
18139       var $11053=(($11047+($11052<<2))|0);
18140       var $11054=$11053;
18141       var $11055=$11054;
18142       var $11056=HEAP32[(($11055)>>2)];
18143       _qcvmerror($11041, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11044,HEAP32[(((tempInt)+(4))>>2)]=$11056,tempInt));
18144       __label__ = 488; break;
18145     case 429:
18146       var $11058=$2;
18147       var $11059=(($11058+64)|0);
18148       var $11060=HEAP32[(($11059)>>2)];
18149       var $11061=$st;
18150       var $11062=(($11061+4)|0);
18151       var $11063=$11062;
18152       var $11064=HEAP16[(($11063)>>1)];
18153       var $11065=(($11064)&65535);
18154       var $11066=(($11060+($11065<<2))|0);
18155       var $11067=$11066;
18156       var $11068=$11067;
18157       var $11069=HEAP32[(($11068)>>2)];
18158       var $11070=$2;
18159       var $11071=(($11070+144)|0);
18160       var $11072=HEAP32[(($11071)>>2)];
18161       var $11073=(($11069)>>>0) < (($11072)>>>0);
18162       if ($11073) { __label__ = 430; break; } else { __label__ = 432; break; }
18163     case 430:
18164       var $11075=$2;
18165       var $11076=(($11075+148)|0);
18166       var $11077=HEAP8[($11076)];
18167       var $11078=(($11077) & 1);
18168       if ($11078) { __label__ = 432; break; } else { __label__ = 431; break; }
18169     case 431:
18170       var $11080=$2;
18171       var $11081=$2;
18172       var $11082=(($11081)|0);
18173       var $11083=HEAP32[(($11082)>>2)];
18174       var $11084=$2;
18175       var $11085=$2;
18176       var $11086=$2;
18177       var $11087=(($11086+64)|0);
18178       var $11088=HEAP32[(($11087)>>2)];
18179       var $11089=$st;
18180       var $11090=(($11089+4)|0);
18181       var $11091=$11090;
18182       var $11092=HEAP16[(($11091)>>1)];
18183       var $11093=(($11092)&65535);
18184       var $11094=(($11088+($11093<<2))|0);
18185       var $11095=$11094;
18186       var $11096=$11095;
18187       var $11097=HEAP32[(($11096)>>2)];
18188       var $11098=_prog_entfield($11085, $11097);
18189       var $11099=(($11098+4)|0);
18190       var $11100=HEAP32[(($11099)>>2)];
18191       var $11101=_prog_getstring($11084, $11100);
18192       var $11102=$2;
18193       var $11103=(($11102+64)|0);
18194       var $11104=HEAP32[(($11103)>>2)];
18195       var $11105=$st;
18196       var $11106=(($11105+4)|0);
18197       var $11107=$11106;
18198       var $11108=HEAP16[(($11107)>>1)];
18199       var $11109=(($11108)&65535);
18200       var $11110=(($11104+($11109<<2))|0);
18201       var $11111=$11110;
18202       var $11112=$11111;
18203       var $11113=HEAP32[(($11112)>>2)];
18204       _qcvmerror($11080, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11083,HEAP32[(((tempInt)+(4))>>2)]=$11101,HEAP32[(((tempInt)+(8))>>2)]=$11113,tempInt));
18205       __label__ = 432; break;
18206     case 432:
18207       var $11115=$2;
18208       var $11116=(($11115+76)|0);
18209       var $11117=HEAP32[(($11116)>>2)];
18210       var $11118=$2;
18211       var $11119=(($11118+64)|0);
18212       var $11120=HEAP32[(($11119)>>2)];
18213       var $11121=$st;
18214       var $11122=(($11121+4)|0);
18215       var $11123=$11122;
18216       var $11124=HEAP16[(($11123)>>1)];
18217       var $11125=(($11124)&65535);
18218       var $11126=(($11120+($11125<<2))|0);
18219       var $11127=$11126;
18220       var $11128=$11127;
18221       var $11129=HEAP32[(($11128)>>2)];
18222       var $11130=(($11117+($11129<<2))|0);
18223       var $11131=$11130;
18224       $ptr11=$11131;
18225       var $11132=$2;
18226       var $11133=(($11132+64)|0);
18227       var $11134=HEAP32[(($11133)>>2)];
18228       var $11135=$st;
18229       var $11136=(($11135+2)|0);
18230       var $11137=$11136;
18231       var $11138=HEAP16[(($11137)>>1)];
18232       var $11139=(($11138)&65535);
18233       var $11140=(($11134+($11139<<2))|0);
18234       var $11141=$11140;
18235       var $11142=$11141;
18236       var $11143=HEAP32[(($11142)>>2)];
18237       var $11144=$ptr11;
18238       var $11145=$11144;
18239       HEAP32[(($11145)>>2)]=$11143;
18240       __label__ = 487; break;
18241     case 433:
18242       var $11147=$2;
18243       var $11148=(($11147+64)|0);
18244       var $11149=HEAP32[(($11148)>>2)];
18245       var $11150=$st;
18246       var $11151=(($11150+4)|0);
18247       var $11152=$11151;
18248       var $11153=HEAP16[(($11152)>>1)];
18249       var $11154=(($11153)&65535);
18250       var $11155=(($11149+($11154<<2))|0);
18251       var $11156=$11155;
18252       var $11157=$11156;
18253       var $11158=HEAP32[(($11157)>>2)];
18254       var $11159=(($11158)|0) < 0;
18255       if ($11159) { __label__ = 435; break; } else { __label__ = 434; break; }
18256     case 434:
18257       var $11161=$2;
18258       var $11162=(($11161+64)|0);
18259       var $11163=HEAP32[(($11162)>>2)];
18260       var $11164=$st;
18261       var $11165=(($11164+4)|0);
18262       var $11166=$11165;
18263       var $11167=HEAP16[(($11166)>>1)];
18264       var $11168=(($11167)&65535);
18265       var $11169=(($11163+($11168<<2))|0);
18266       var $11170=$11169;
18267       var $11171=$11170;
18268       var $11172=HEAP32[(($11171)>>2)];
18269       var $11173=((($11172)+(2))|0);
18270       var $11174=$2;
18271       var $11175=(($11174+80)|0);
18272       var $11176=HEAP32[(($11175)>>2)];
18273       var $11177=(($11173)>>>0) >= (($11176)>>>0);
18274       if ($11177) { __label__ = 435; break; } else { __label__ = 436; break; }
18275     case 435:
18276       var $11179=$2;
18277       var $11180=$2;
18278       var $11181=(($11180)|0);
18279       var $11182=HEAP32[(($11181)>>2)];
18280       var $11183=$2;
18281       var $11184=(($11183+64)|0);
18282       var $11185=HEAP32[(($11184)>>2)];
18283       var $11186=$st;
18284       var $11187=(($11186+4)|0);
18285       var $11188=$11187;
18286       var $11189=HEAP16[(($11188)>>1)];
18287       var $11190=(($11189)&65535);
18288       var $11191=(($11185+($11190<<2))|0);
18289       var $11192=$11191;
18290       var $11193=$11192;
18291       var $11194=HEAP32[(($11193)>>2)];
18292       _qcvmerror($11179, ((STRING_TABLE.__str20)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11182,HEAP32[(((tempInt)+(4))>>2)]=$11194,tempInt));
18293       __label__ = 488; break;
18294     case 436:
18295       var $11196=$2;
18296       var $11197=(($11196+64)|0);
18297       var $11198=HEAP32[(($11197)>>2)];
18298       var $11199=$st;
18299       var $11200=(($11199+4)|0);
18300       var $11201=$11200;
18301       var $11202=HEAP16[(($11201)>>1)];
18302       var $11203=(($11202)&65535);
18303       var $11204=(($11198+($11203<<2))|0);
18304       var $11205=$11204;
18305       var $11206=$11205;
18306       var $11207=HEAP32[(($11206)>>2)];
18307       var $11208=$2;
18308       var $11209=(($11208+144)|0);
18309       var $11210=HEAP32[(($11209)>>2)];
18310       var $11211=(($11207)>>>0) < (($11210)>>>0);
18311       if ($11211) { __label__ = 437; break; } else { __label__ = 439; break; }
18312     case 437:
18313       var $11213=$2;
18314       var $11214=(($11213+148)|0);
18315       var $11215=HEAP8[($11214)];
18316       var $11216=(($11215) & 1);
18317       if ($11216) { __label__ = 439; break; } else { __label__ = 438; break; }
18318     case 438:
18319       var $11218=$2;
18320       var $11219=$2;
18321       var $11220=(($11219)|0);
18322       var $11221=HEAP32[(($11220)>>2)];
18323       var $11222=$2;
18324       var $11223=$2;
18325       var $11224=$2;
18326       var $11225=(($11224+64)|0);
18327       var $11226=HEAP32[(($11225)>>2)];
18328       var $11227=$st;
18329       var $11228=(($11227+4)|0);
18330       var $11229=$11228;
18331       var $11230=HEAP16[(($11229)>>1)];
18332       var $11231=(($11230)&65535);
18333       var $11232=(($11226+($11231<<2))|0);
18334       var $11233=$11232;
18335       var $11234=$11233;
18336       var $11235=HEAP32[(($11234)>>2)];
18337       var $11236=_prog_entfield($11223, $11235);
18338       var $11237=(($11236+4)|0);
18339       var $11238=HEAP32[(($11237)>>2)];
18340       var $11239=_prog_getstring($11222, $11238);
18341       var $11240=$2;
18342       var $11241=(($11240+64)|0);
18343       var $11242=HEAP32[(($11241)>>2)];
18344       var $11243=$st;
18345       var $11244=(($11243+4)|0);
18346       var $11245=$11244;
18347       var $11246=HEAP16[(($11245)>>1)];
18348       var $11247=(($11246)&65535);
18349       var $11248=(($11242+($11247<<2))|0);
18350       var $11249=$11248;
18351       var $11250=$11249;
18352       var $11251=HEAP32[(($11250)>>2)];
18353       _qcvmerror($11218, ((STRING_TABLE.__str21)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11221,HEAP32[(((tempInt)+(4))>>2)]=$11239,HEAP32[(((tempInt)+(8))>>2)]=$11251,tempInt));
18354       __label__ = 439; break;
18355     case 439:
18356       var $11253=$2;
18357       var $11254=(($11253+76)|0);
18358       var $11255=HEAP32[(($11254)>>2)];
18359       var $11256=$2;
18360       var $11257=(($11256+64)|0);
18361       var $11258=HEAP32[(($11257)>>2)];
18362       var $11259=$st;
18363       var $11260=(($11259+4)|0);
18364       var $11261=$11260;
18365       var $11262=HEAP16[(($11261)>>1)];
18366       var $11263=(($11262)&65535);
18367       var $11264=(($11258+($11263<<2))|0);
18368       var $11265=$11264;
18369       var $11266=$11265;
18370       var $11267=HEAP32[(($11266)>>2)];
18371       var $11268=(($11255+($11267<<2))|0);
18372       var $11269=$11268;
18373       $ptr11=$11269;
18374       var $11270=$2;
18375       var $11271=(($11270+64)|0);
18376       var $11272=HEAP32[(($11271)>>2)];
18377       var $11273=$st;
18378       var $11274=(($11273+2)|0);
18379       var $11275=$11274;
18380       var $11276=HEAP16[(($11275)>>1)];
18381       var $11277=(($11276)&65535);
18382       var $11278=(($11272+($11277<<2))|0);
18383       var $11279=$11278;
18384       var $11280=$11279;
18385       var $11281=(($11280)|0);
18386       var $11282=HEAP32[(($11281)>>2)];
18387       var $11283=$ptr11;
18388       var $11284=$11283;
18389       var $11285=(($11284)|0);
18390       HEAP32[(($11285)>>2)]=$11282;
18391       var $11286=$2;
18392       var $11287=(($11286+64)|0);
18393       var $11288=HEAP32[(($11287)>>2)];
18394       var $11289=$st;
18395       var $11290=(($11289+2)|0);
18396       var $11291=$11290;
18397       var $11292=HEAP16[(($11291)>>1)];
18398       var $11293=(($11292)&65535);
18399       var $11294=(($11288+($11293<<2))|0);
18400       var $11295=$11294;
18401       var $11296=$11295;
18402       var $11297=(($11296+4)|0);
18403       var $11298=HEAP32[(($11297)>>2)];
18404       var $11299=$ptr11;
18405       var $11300=$11299;
18406       var $11301=(($11300+4)|0);
18407       HEAP32[(($11301)>>2)]=$11298;
18408       var $11302=$2;
18409       var $11303=(($11302+64)|0);
18410       var $11304=HEAP32[(($11303)>>2)];
18411       var $11305=$st;
18412       var $11306=(($11305+2)|0);
18413       var $11307=$11306;
18414       var $11308=HEAP16[(($11307)>>1)];
18415       var $11309=(($11308)&65535);
18416       var $11310=(($11304+($11309<<2))|0);
18417       var $11311=$11310;
18418       var $11312=$11311;
18419       var $11313=(($11312+8)|0);
18420       var $11314=HEAP32[(($11313)>>2)];
18421       var $11315=$ptr11;
18422       var $11316=$11315;
18423       var $11317=(($11316+8)|0);
18424       HEAP32[(($11317)>>2)]=$11314;
18425       __label__ = 487; break;
18426     case 440:
18427       var $11319=$2;
18428       var $11320=(($11319+64)|0);
18429       var $11321=HEAP32[(($11320)>>2)];
18430       var $11322=$st;
18431       var $11323=(($11322+2)|0);
18432       var $11324=$11323;
18433       var $11325=HEAP16[(($11324)>>1)];
18434       var $11326=(($11325)&65535);
18435       var $11327=(($11321+($11326<<2))|0);
18436       var $11328=$11327;
18437       var $11329=$11328;
18438       var $11330=HEAP32[(($11329)>>2)];
18439       var $11331=$11330 & 2147483647;
18440       var $11332=(($11331)|0)!=0;
18441       var $11333=$11332 ^ 1;
18442       var $11334=(($11333)&1);
18443       var $11335=(($11334)|0);
18444       var $11336=$2;
18445       var $11337=(($11336+64)|0);
18446       var $11338=HEAP32[(($11337)>>2)];
18447       var $11339=$st;
18448       var $11340=(($11339+6)|0);
18449       var $11341=$11340;
18450       var $11342=HEAP16[(($11341)>>1)];
18451       var $11343=(($11342)&65535);
18452       var $11344=(($11338+($11343<<2))|0);
18453       var $11345=$11344;
18454       var $11346=$11345;
18455       HEAPF32[(($11346)>>2)]=$11335;
18456       __label__ = 487; break;
18457     case 441:
18458       var $11348=$2;
18459       var $11349=(($11348+64)|0);
18460       var $11350=HEAP32[(($11349)>>2)];
18461       var $11351=$st;
18462       var $11352=(($11351+2)|0);
18463       var $11353=$11352;
18464       var $11354=HEAP16[(($11353)>>1)];
18465       var $11355=(($11354)&65535);
18466       var $11356=(($11350+($11355<<2))|0);
18467       var $11357=$11356;
18468       var $11358=$11357;
18469       var $11359=(($11358)|0);
18470       var $11360=HEAPF32[(($11359)>>2)];
18471       var $11361=$11360 != 0;
18472       if ($11361) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 442; break; }
18473     case 442:
18474       var $11363=$2;
18475       var $11364=(($11363+64)|0);
18476       var $11365=HEAP32[(($11364)>>2)];
18477       var $11366=$st;
18478       var $11367=(($11366+2)|0);
18479       var $11368=$11367;
18480       var $11369=HEAP16[(($11368)>>1)];
18481       var $11370=(($11369)&65535);
18482       var $11371=(($11365+($11370<<2))|0);
18483       var $11372=$11371;
18484       var $11373=$11372;
18485       var $11374=(($11373+4)|0);
18486       var $11375=HEAPF32[(($11374)>>2)];
18487       var $11376=$11375 != 0;
18488       if ($11376) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 443; break; }
18489     case 443:
18490       var $11378=$2;
18491       var $11379=(($11378+64)|0);
18492       var $11380=HEAP32[(($11379)>>2)];
18493       var $11381=$st;
18494       var $11382=(($11381+2)|0);
18495       var $11383=$11382;
18496       var $11384=HEAP16[(($11383)>>1)];
18497       var $11385=(($11384)&65535);
18498       var $11386=(($11380+($11385<<2))|0);
18499       var $11387=$11386;
18500       var $11388=$11387;
18501       var $11389=(($11388+8)|0);
18502       var $11390=HEAPF32[(($11389)>>2)];
18503       var $11391=$11390 != 0;
18504       var $11392=$11391 ^ 1;
18505       var $11394 = $11392;__label__ = 444; break;
18506     case 444:
18507       var $11394;
18508       var $11395=(($11394)&1);
18509       var $11396=(($11395)|0);
18510       var $11397=$2;
18511       var $11398=(($11397+64)|0);
18512       var $11399=HEAP32[(($11398)>>2)];
18513       var $11400=$st;
18514       var $11401=(($11400+6)|0);
18515       var $11402=$11401;
18516       var $11403=HEAP16[(($11402)>>1)];
18517       var $11404=(($11403)&65535);
18518       var $11405=(($11399+($11404<<2))|0);
18519       var $11406=$11405;
18520       var $11407=$11406;
18521       HEAPF32[(($11407)>>2)]=$11396;
18522       __label__ = 487; break;
18523     case 445:
18524       var $11409=$2;
18525       var $11410=(($11409+64)|0);
18526       var $11411=HEAP32[(($11410)>>2)];
18527       var $11412=$st;
18528       var $11413=(($11412+2)|0);
18529       var $11414=$11413;
18530       var $11415=HEAP16[(($11414)>>1)];
18531       var $11416=(($11415)&65535);
18532       var $11417=(($11411+($11416<<2))|0);
18533       var $11418=$11417;
18534       var $11419=$11418;
18535       var $11420=HEAP32[(($11419)>>2)];
18536       var $11421=(($11420)|0)!=0;
18537       if ($11421) { __label__ = 446; break; } else { var $11441 = 1;__label__ = 447; break; }
18538     case 446:
18539       var $11423=$2;
18540       var $11424=$2;
18541       var $11425=(($11424+64)|0);
18542       var $11426=HEAP32[(($11425)>>2)];
18543       var $11427=$st;
18544       var $11428=(($11427+2)|0);
18545       var $11429=$11428;
18546       var $11430=HEAP16[(($11429)>>1)];
18547       var $11431=(($11430)&65535);
18548       var $11432=(($11426+($11431<<2))|0);
18549       var $11433=$11432;
18550       var $11434=$11433;
18551       var $11435=HEAP32[(($11434)>>2)];
18552       var $11436=_prog_getstring($11423, $11435);
18553       var $11437=HEAP8[($11436)];
18554       var $11438=(($11437 << 24) >> 24)!=0;
18555       var $11439=$11438 ^ 1;
18556       var $11441 = $11439;__label__ = 447; break;
18557     case 447:
18558       var $11441;
18559       var $11442=(($11441)&1);
18560       var $11443=(($11442)|0);
18561       var $11444=$2;
18562       var $11445=(($11444+64)|0);
18563       var $11446=HEAP32[(($11445)>>2)];
18564       var $11447=$st;
18565       var $11448=(($11447+6)|0);
18566       var $11449=$11448;
18567       var $11450=HEAP16[(($11449)>>1)];
18568       var $11451=(($11450)&65535);
18569       var $11452=(($11446+($11451<<2))|0);
18570       var $11453=$11452;
18571       var $11454=$11453;
18572       HEAPF32[(($11454)>>2)]=$11443;
18573       __label__ = 487; break;
18574     case 448:
18575       var $11456=$2;
18576       var $11457=(($11456+64)|0);
18577       var $11458=HEAP32[(($11457)>>2)];
18578       var $11459=$st;
18579       var $11460=(($11459+2)|0);
18580       var $11461=$11460;
18581       var $11462=HEAP16[(($11461)>>1)];
18582       var $11463=(($11462)&65535);
18583       var $11464=(($11458+($11463<<2))|0);
18584       var $11465=$11464;
18585       var $11466=$11465;
18586       var $11467=HEAP32[(($11466)>>2)];
18587       var $11468=(($11467)|0)==0;
18588       var $11469=(($11468)&1);
18589       var $11470=(($11469)|0);
18590       var $11471=$2;
18591       var $11472=(($11471+64)|0);
18592       var $11473=HEAP32[(($11472)>>2)];
18593       var $11474=$st;
18594       var $11475=(($11474+6)|0);
18595       var $11476=$11475;
18596       var $11477=HEAP16[(($11476)>>1)];
18597       var $11478=(($11477)&65535);
18598       var $11479=(($11473+($11478<<2))|0);
18599       var $11480=$11479;
18600       var $11481=$11480;
18601       HEAPF32[(($11481)>>2)]=$11470;
18602       __label__ = 487; break;
18603     case 449:
18604       var $11483=$2;
18605       var $11484=(($11483+64)|0);
18606       var $11485=HEAP32[(($11484)>>2)];
18607       var $11486=$st;
18608       var $11487=(($11486+2)|0);
18609       var $11488=$11487;
18610       var $11489=HEAP16[(($11488)>>1)];
18611       var $11490=(($11489)&65535);
18612       var $11491=(($11485+($11490<<2))|0);
18613       var $11492=$11491;
18614       var $11493=$11492;
18615       var $11494=HEAP32[(($11493)>>2)];
18616       var $11495=(($11494)|0)!=0;
18617       var $11496=$11495 ^ 1;
18618       var $11497=(($11496)&1);
18619       var $11498=(($11497)|0);
18620       var $11499=$2;
18621       var $11500=(($11499+64)|0);
18622       var $11501=HEAP32[(($11500)>>2)];
18623       var $11502=$st;
18624       var $11503=(($11502+6)|0);
18625       var $11504=$11503;
18626       var $11505=HEAP16[(($11504)>>1)];
18627       var $11506=(($11505)&65535);
18628       var $11507=(($11501+($11506<<2))|0);
18629       var $11508=$11507;
18630       var $11509=$11508;
18631       HEAPF32[(($11509)>>2)]=$11498;
18632       __label__ = 487; break;
18633     case 450:
18634       var $11511=$2;
18635       var $11512=(($11511+64)|0);
18636       var $11513=HEAP32[(($11512)>>2)];
18637       var $11514=$st;
18638       var $11515=(($11514+2)|0);
18639       var $11516=$11515;
18640       var $11517=HEAP16[(($11516)>>1)];
18641       var $11518=(($11517)&65535);
18642       var $11519=(($11513+($11518<<2))|0);
18643       var $11520=$11519;
18644       var $11521=$11520;
18645       var $11522=HEAP32[(($11521)>>2)];
18646       var $11523=$11522 & 2147483647;
18647       var $11524=(($11523)|0)!=0;
18648       if ($11524) { __label__ = 451; break; } else { __label__ = 454; break; }
18649     case 451:
18650       var $11526=$st;
18651       var $11527=(($11526+4)|0);
18652       var $11528=$11527;
18653       var $11529=HEAP16[(($11528)>>1)];
18654       var $11530=(($11529 << 16) >> 16);
18655       var $11531=((($11530)-(1))|0);
18656       var $11532=$st;
18657       var $11533=(($11532+($11531<<3))|0);
18658       $st=$11533;
18659       var $11534=$jumpcount;
18660       var $11535=((($11534)+(1))|0);
18661       $jumpcount=$11535;
18662       var $11536=$5;
18663       var $11537=(($11535)|0) >= (($11536)|0);
18664       if ($11537) { __label__ = 452; break; } else { __label__ = 453; break; }
18665     case 452:
18666       var $11539=$2;
18667       var $11540=$2;
18668       var $11541=(($11540)|0);
18669       var $11542=HEAP32[(($11541)>>2)];
18670       var $11543=$jumpcount;
18671       _qcvmerror($11539, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11542,HEAP32[(((tempInt)+(4))>>2)]=$11543,tempInt));
18672       __label__ = 453; break;
18673     case 453:
18674       __label__ = 454; break;
18675     case 454:
18676       __label__ = 487; break;
18677     case 455:
18678       var $11547=$2;
18679       var $11548=(($11547+64)|0);
18680       var $11549=HEAP32[(($11548)>>2)];
18681       var $11550=$st;
18682       var $11551=(($11550+2)|0);
18683       var $11552=$11551;
18684       var $11553=HEAP16[(($11552)>>1)];
18685       var $11554=(($11553)&65535);
18686       var $11555=(($11549+($11554<<2))|0);
18687       var $11556=$11555;
18688       var $11557=$11556;
18689       var $11558=HEAP32[(($11557)>>2)];
18690       var $11559=$11558 & 2147483647;
18691       var $11560=(($11559)|0)!=0;
18692       if ($11560) { __label__ = 459; break; } else { __label__ = 456; break; }
18693     case 456:
18694       var $11562=$st;
18695       var $11563=(($11562+4)|0);
18696       var $11564=$11563;
18697       var $11565=HEAP16[(($11564)>>1)];
18698       var $11566=(($11565 << 16) >> 16);
18699       var $11567=((($11566)-(1))|0);
18700       var $11568=$st;
18701       var $11569=(($11568+($11567<<3))|0);
18702       $st=$11569;
18703       var $11570=$jumpcount;
18704       var $11571=((($11570)+(1))|0);
18705       $jumpcount=$11571;
18706       var $11572=$5;
18707       var $11573=(($11571)|0) >= (($11572)|0);
18708       if ($11573) { __label__ = 457; break; } else { __label__ = 458; break; }
18709     case 457:
18710       var $11575=$2;
18711       var $11576=$2;
18712       var $11577=(($11576)|0);
18713       var $11578=HEAP32[(($11577)>>2)];
18714       var $11579=$jumpcount;
18715       _qcvmerror($11575, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11578,HEAP32[(((tempInt)+(4))>>2)]=$11579,tempInt));
18716       __label__ = 458; break;
18717     case 458:
18718       __label__ = 459; break;
18719     case 459:
18720       __label__ = 487; break;
18721     case 460:
18722       var $11583=$st;
18723       var $11584=(($11583)|0);
18724       var $11585=HEAP16[(($11584)>>1)];
18725       var $11586=(($11585)&65535);
18726       var $11587=((($11586)-(51))|0);
18727       var $11588=$2;
18728       var $11589=(($11588+184)|0);
18729       HEAP32[(($11589)>>2)]=$11587;
18730       var $11590=$2;
18731       var $11591=(($11590+64)|0);
18732       var $11592=HEAP32[(($11591)>>2)];
18733       var $11593=$st;
18734       var $11594=(($11593+2)|0);
18735       var $11595=$11594;
18736       var $11596=HEAP16[(($11595)>>1)];
18737       var $11597=(($11596)&65535);
18738       var $11598=(($11592+($11597<<2))|0);
18739       var $11599=$11598;
18740       var $11600=$11599;
18741       var $11601=HEAP32[(($11600)>>2)];
18742       var $11602=(($11601)|0)!=0;
18743       if ($11602) { __label__ = 462; break; } else { __label__ = 461; break; }
18744     case 461:
18745       var $11604=$2;
18746       var $11605=$2;
18747       var $11606=(($11605)|0);
18748       var $11607=HEAP32[(($11606)>>2)];
18749       _qcvmerror($11604, ((STRING_TABLE.__str23)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11607,tempInt));
18750       __label__ = 462; break;
18751     case 462:
18752       var $11609=$2;
18753       var $11610=(($11609+64)|0);
18754       var $11611=HEAP32[(($11610)>>2)];
18755       var $11612=$st;
18756       var $11613=(($11612+2)|0);
18757       var $11614=$11613;
18758       var $11615=HEAP16[(($11614)>>1)];
18759       var $11616=(($11615)&65535);
18760       var $11617=(($11611+($11616<<2))|0);
18761       var $11618=$11617;
18762       var $11619=$11618;
18763       var $11620=HEAP32[(($11619)>>2)];
18764       var $11621=(($11620)|0)!=0;
18765       if ($11621) { __label__ = 463; break; } else { __label__ = 464; break; }
18766     case 463:
18767       var $11623=$2;
18768       var $11624=(($11623+64)|0);
18769       var $11625=HEAP32[(($11624)>>2)];
18770       var $11626=$st;
18771       var $11627=(($11626+2)|0);
18772       var $11628=$11627;
18773       var $11629=HEAP16[(($11628)>>1)];
18774       var $11630=(($11629)&65535);
18775       var $11631=(($11625+($11630<<2))|0);
18776       var $11632=$11631;
18777       var $11633=$11632;
18778       var $11634=HEAP32[(($11633)>>2)];
18779       var $11635=$2;
18780       var $11636=(($11635+44)|0);
18781       var $11637=HEAP32[(($11636)>>2)];
18782       var $11638=(($11634)>>>0) >= (($11637)>>>0);
18783       if ($11638) { __label__ = 464; break; } else { __label__ = 465; break; }
18784     case 464:
18785       var $11640=$2;
18786       var $11641=$2;
18787       var $11642=(($11641)|0);
18788       var $11643=HEAP32[(($11642)>>2)];
18789       _qcvmerror($11640, ((STRING_TABLE.__str24)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11643,tempInt));
18790       __label__ = 488; break;
18791     case 465:
18792       var $11645=$2;
18793       var $11646=(($11645+64)|0);
18794       var $11647=HEAP32[(($11646)>>2)];
18795       var $11648=$st;
18796       var $11649=(($11648+2)|0);
18797       var $11650=$11649;
18798       var $11651=HEAP16[(($11650)>>1)];
18799       var $11652=(($11651)&65535);
18800       var $11653=(($11647+($11652<<2))|0);
18801       var $11654=$11653;
18802       var $11655=$11654;
18803       var $11656=HEAP32[(($11655)>>2)];
18804       var $11657=$2;
18805       var $11658=(($11657+40)|0);
18806       var $11659=HEAP32[(($11658)>>2)];
18807       var $11660=(($11659+($11656)*(36))|0);
18808       $newf9=$11660;
18809       var $11661=$newf9;
18810       var $11662=(($11661+12)|0);
18811       var $11663=HEAP32[(($11662)>>2)];
18812       var $11664=((($11663)+(1))|0);
18813       HEAP32[(($11662)>>2)]=$11664;
18814       var $11665=$st;
18815       var $11666=$2;
18816       var $11667=(($11666+4)|0);
18817       var $11668=HEAP32[(($11667)>>2)];
18818       var $11669=$11665;
18819       var $11670=$11668;
18820       var $11671=((($11669)-($11670))|0);
18821       var $11672=((((($11671)|0))/(8))&-1);
18822       var $11673=((($11672)+(1))|0);
18823       var $11674=$2;
18824       var $11675=(($11674+176)|0);
18825       HEAP32[(($11675)>>2)]=$11673;
18826       var $11676=$newf9;
18827       var $11677=(($11676)|0);
18828       var $11678=HEAP32[(($11677)>>2)];
18829       var $11679=(($11678)|0) < 0;
18830       if ($11679) { __label__ = 466; break; } else { __label__ = 471; break; }
18831     case 466:
18832       var $11681=$newf9;
18833       var $11682=(($11681)|0);
18834       var $11683=HEAP32[(($11682)>>2)];
18835       var $11684=(((-$11683))|0);
18836       $builtinnumber12=$11684;
18837       var $11685=$builtinnumber12;
18838       var $11686=$2;
18839       var $11687=(($11686+132)|0);
18840       var $11688=HEAP32[(($11687)>>2)];
18841       var $11689=(($11685)>>>0) < (($11688)>>>0);
18842       if ($11689) { __label__ = 467; break; } else { __label__ = 469; break; }
18843     case 467:
18844       var $11691=$builtinnumber12;
18845       var $11692=$2;
18846       var $11693=(($11692+128)|0);
18847       var $11694=HEAP32[(($11693)>>2)];
18848       var $11695=(($11694+($11691<<2))|0);
18849       var $11696=HEAP32[(($11695)>>2)];
18850       var $11697=(($11696)|0)!=0;
18851       if ($11697) { __label__ = 468; break; } else { __label__ = 469; break; }
18852     case 468:
18853       var $11699=$builtinnumber12;
18854       var $11700=$2;
18855       var $11701=(($11700+128)|0);
18856       var $11702=HEAP32[(($11701)>>2)];
18857       var $11703=(($11702+($11699<<2))|0);
18858       var $11704=HEAP32[(($11703)>>2)];
18859       var $11705=$2;
18860       var $11706=FUNCTION_TABLE[$11704]($11705);
18861       __label__ = 470; break;
18862     case 469:
18863       var $11708=$2;
18864       var $11709=$builtinnumber12;
18865       var $11710=$2;
18866       var $11711=(($11710)|0);
18867       var $11712=HEAP32[(($11711)>>2)];
18868       _qcvmerror($11708, ((STRING_TABLE.__str25)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11709,HEAP32[(((tempInt)+(4))>>2)]=$11712,tempInt));
18869       __label__ = 470; break;
18870     case 470:
18871       __label__ = 472; break;
18872     case 471:
18873       var $11715=$2;
18874       var $11716=(($11715+4)|0);
18875       var $11717=HEAP32[(($11716)>>2)];
18876       var $11718=$2;
18877       var $11719=$newf9;
18878       var $11720=_prog_enterfunction($11718, $11719);
18879       var $11721=(($11717+($11720<<3))|0);
18880       var $11722=((($11721)-(8))|0);
18881       $st=$11722;
18882       __label__ = 472; break;
18883     case 472:
18884       var $11724=$2;
18885       var $11725=(($11724+112)|0);
18886       var $11726=HEAP32[(($11725)>>2)];
18887       var $11727=(($11726)|0)!=0;
18888       if ($11727) { __label__ = 473; break; } else { __label__ = 474; break; }
18889     case 473:
18890       __label__ = 488; break;
18891     case 474:
18892       __label__ = 487; break;
18893     case 475:
18894       var $11731=$2;
18895       var $11732=$2;
18896       var $11733=(($11732)|0);
18897       var $11734=HEAP32[(($11733)>>2)];
18898       _qcvmerror($11731, ((STRING_TABLE.__str26)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11734,tempInt));
18899       __label__ = 487; break;
18900     case 476:
18901       var $11736=$st;
18902       var $11737=(($11736+2)|0);
18903       var $11738=$11737;
18904       var $11739=HEAP16[(($11738)>>1)];
18905       var $11740=(($11739 << 16) >> 16);
18906       var $11741=((($11740)-(1))|0);
18907       var $11742=$st;
18908       var $11743=(($11742+($11741<<3))|0);
18909       $st=$11743;
18910       var $11744=$jumpcount;
18911       var $11745=((($11744)+(1))|0);
18912       $jumpcount=$11745;
18913       var $11746=(($11745)|0)==10000000;
18914       if ($11746) { __label__ = 477; break; } else { __label__ = 478; break; }
18915     case 477:
18916       var $11748=$2;
18917       var $11749=$2;
18918       var $11750=(($11749)|0);
18919       var $11751=HEAP32[(($11750)>>2)];
18920       var $11752=$jumpcount;
18921       _qcvmerror($11748, ((STRING_TABLE.__str22)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$11751,HEAP32[(((tempInt)+(4))>>2)]=$11752,tempInt));
18922       __label__ = 478; break;
18923     case 478:
18924       __label__ = 487; break;
18925     case 479:
18926       var $11755=$2;
18927       var $11756=(($11755+64)|0);
18928       var $11757=HEAP32[(($11756)>>2)];
18929       var $11758=$st;
18930       var $11759=(($11758+2)|0);
18931       var $11760=$11759;
18932       var $11761=HEAP16[(($11760)>>1)];
18933       var $11762=(($11761)&65535);
18934       var $11763=(($11757+($11762<<2))|0);
18935       var $11764=$11763;
18936       var $11765=$11764;
18937       var $11766=HEAP32[(($11765)>>2)];
18938       var $11767=$11766 & 2147483647;
18939       var $11768=(($11767)|0)!=0;
18940       if ($11768) { __label__ = 480; break; } else { var $11785 = 0;__label__ = 481; break; }
18941     case 480:
18942       var $11770=$2;
18943       var $11771=(($11770+64)|0);
18944       var $11772=HEAP32[(($11771)>>2)];
18945       var $11773=$st;
18946       var $11774=(($11773+4)|0);
18947       var $11775=$11774;
18948       var $11776=HEAP16[(($11775)>>1)];
18949       var $11777=(($11776)&65535);
18950       var $11778=(($11772+($11777<<2))|0);
18951       var $11779=$11778;
18952       var $11780=$11779;
18953       var $11781=HEAP32[(($11780)>>2)];
18954       var $11782=$11781 & 2147483647;
18955       var $11783=(($11782)|0)!=0;
18956       var $11785 = $11783;__label__ = 481; break;
18957     case 481:
18958       var $11785;
18959       var $11786=(($11785)&1);
18960       var $11787=(($11786)|0);
18961       var $11788=$2;
18962       var $11789=(($11788+64)|0);
18963       var $11790=HEAP32[(($11789)>>2)];
18964       var $11791=$st;
18965       var $11792=(($11791+6)|0);
18966       var $11793=$11792;
18967       var $11794=HEAP16[(($11793)>>1)];
18968       var $11795=(($11794)&65535);
18969       var $11796=(($11790+($11795<<2))|0);
18970       var $11797=$11796;
18971       var $11798=$11797;
18972       HEAPF32[(($11798)>>2)]=$11787;
18973       __label__ = 487; break;
18974     case 482:
18975       var $11800=$2;
18976       var $11801=(($11800+64)|0);
18977       var $11802=HEAP32[(($11801)>>2)];
18978       var $11803=$st;
18979       var $11804=(($11803+2)|0);
18980       var $11805=$11804;
18981       var $11806=HEAP16[(($11805)>>1)];
18982       var $11807=(($11806)&65535);
18983       var $11808=(($11802+($11807<<2))|0);
18984       var $11809=$11808;
18985       var $11810=$11809;
18986       var $11811=HEAP32[(($11810)>>2)];
18987       var $11812=$11811 & 2147483647;
18988       var $11813=(($11812)|0)!=0;
18989       if ($11813) { var $11830 = 1;__label__ = 484; break; } else { __label__ = 483; break; }
18990     case 483:
18991       var $11815=$2;
18992       var $11816=(($11815+64)|0);
18993       var $11817=HEAP32[(($11816)>>2)];
18994       var $11818=$st;
18995       var $11819=(($11818+4)|0);
18996       var $11820=$11819;
18997       var $11821=HEAP16[(($11820)>>1)];
18998       var $11822=(($11821)&65535);
18999       var $11823=(($11817+($11822<<2))|0);
19000       var $11824=$11823;
19001       var $11825=$11824;
19002       var $11826=HEAP32[(($11825)>>2)];
19003       var $11827=$11826 & 2147483647;
19004       var $11828=(($11827)|0)!=0;
19005       var $11830 = $11828;__label__ = 484; break;
19006     case 484:
19007       var $11830;
19008       var $11831=(($11830)&1);
19009       var $11832=(($11831)|0);
19010       var $11833=$2;
19011       var $11834=(($11833+64)|0);
19012       var $11835=HEAP32[(($11834)>>2)];
19013       var $11836=$st;
19014       var $11837=(($11836+6)|0);
19015       var $11838=$11837;
19016       var $11839=HEAP16[(($11838)>>1)];
19017       var $11840=(($11839)&65535);
19018       var $11841=(($11835+($11840<<2))|0);
19019       var $11842=$11841;
19020       var $11843=$11842;
19021       HEAPF32[(($11843)>>2)]=$11832;
19022       __label__ = 487; break;
19023     case 485:
19024       var $11845=$2;
19025       var $11846=(($11845+64)|0);
19026       var $11847=HEAP32[(($11846)>>2)];
19027       var $11848=$st;
19028       var $11849=(($11848+2)|0);
19029       var $11850=$11849;
19030       var $11851=HEAP16[(($11850)>>1)];
19031       var $11852=(($11851)&65535);
19032       var $11853=(($11847+($11852<<2))|0);
19033       var $11854=$11853;
19034       var $11855=$11854;
19035       var $11856=HEAPF32[(($11855)>>2)];
19036       var $11857=(($11856)&-1);
19037       var $11858=$2;
19038       var $11859=(($11858+64)|0);
19039       var $11860=HEAP32[(($11859)>>2)];
19040       var $11861=$st;
19041       var $11862=(($11861+4)|0);
19042       var $11863=$11862;
19043       var $11864=HEAP16[(($11863)>>1)];
19044       var $11865=(($11864)&65535);
19045       var $11866=(($11860+($11865<<2))|0);
19046       var $11867=$11866;
19047       var $11868=$11867;
19048       var $11869=HEAPF32[(($11868)>>2)];
19049       var $11870=(($11869)&-1);
19050       var $11871=$11857 & $11870;
19051       var $11872=(($11871)|0);
19052       var $11873=$2;
19053       var $11874=(($11873+64)|0);
19054       var $11875=HEAP32[(($11874)>>2)];
19055       var $11876=$st;
19056       var $11877=(($11876+6)|0);
19057       var $11878=$11877;
19058       var $11879=HEAP16[(($11878)>>1)];
19059       var $11880=(($11879)&65535);
19060       var $11881=(($11875+($11880<<2))|0);
19061       var $11882=$11881;
19062       var $11883=$11882;
19063       HEAPF32[(($11883)>>2)]=$11872;
19064       __label__ = 487; break;
19065     case 486:
19066       var $11885=$2;
19067       var $11886=(($11885+64)|0);
19068       var $11887=HEAP32[(($11886)>>2)];
19069       var $11888=$st;
19070       var $11889=(($11888+2)|0);
19071       var $11890=$11889;
19072       var $11891=HEAP16[(($11890)>>1)];
19073       var $11892=(($11891)&65535);
19074       var $11893=(($11887+($11892<<2))|0);
19075       var $11894=$11893;
19076       var $11895=$11894;
19077       var $11896=HEAPF32[(($11895)>>2)];
19078       var $11897=(($11896)&-1);
19079       var $11898=$2;
19080       var $11899=(($11898+64)|0);
19081       var $11900=HEAP32[(($11899)>>2)];
19082       var $11901=$st;
19083       var $11902=(($11901+4)|0);
19084       var $11903=$11902;
19085       var $11904=HEAP16[(($11903)>>1)];
19086       var $11905=(($11904)&65535);
19087       var $11906=(($11900+($11905<<2))|0);
19088       var $11907=$11906;
19089       var $11908=$11907;
19090       var $11909=HEAPF32[(($11908)>>2)];
19091       var $11910=(($11909)&-1);
19092       var $11911=$11897 | $11910;
19093       var $11912=(($11911)|0);
19094       var $11913=$2;
19095       var $11914=(($11913+64)|0);
19096       var $11915=HEAP32[(($11914)>>2)];
19097       var $11916=$st;
19098       var $11917=(($11916+6)|0);
19099       var $11918=$11917;
19100       var $11919=HEAP16[(($11918)>>1)];
19101       var $11920=(($11919)&65535);
19102       var $11921=(($11915+($11920<<2))|0);
19103       var $11922=$11921;
19104       var $11923=$11922;
19105       HEAPF32[(($11923)>>2)]=$11912;
19106       __label__ = 487; break;
19107     case 487:
19108       __label__ = 368; break;
19109     case 488:
19110       var $11926=$oldxflags;
19111       var $11927=$2;
19112       var $11928=(($11927+180)|0);
19113       HEAP32[(($11928)>>2)]=$11926;
19114       var $11929=$2;
19115       var $11930=(($11929+156)|0);
19116       HEAP32[(($11930)>>2)]=0;
19117       var $11931=$2;
19118       var $11932=(($11931+168)|0);
19119       HEAP32[(($11932)>>2)]=0;
19120       var $11933=$2;
19121       var $11934=(($11933+112)|0);
19122       var $11935=HEAP32[(($11934)>>2)];
19123       var $11936=(($11935)|0)!=0;
19124       if ($11936) { __label__ = 489; break; } else { __label__ = 490; break; }
19125     case 489:
19126       $1=0;
19127       __label__ = 491; break;
19128     case 490:
19129       $1=1;
19130       __label__ = 491; break;
19131     case 491:
19132       var $11940=$1;
19133       STACKTOP = __stackBase__;
19134       return $11940;
19135     default: assert(0, "bad label: " + __label__);
19136   }
19137 }
19138 _prog_exec["X"]=1;
19139
19140 function _qcvmerror($prog, $fmt) {
19141   var __stackBase__  = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19142   var __label__;
19143
19144   var $1;
19145   var $2;
19146   var $ap=__stackBase__;
19147   $1=$prog;
19148   $2=$fmt;
19149   var $3=$1;
19150   var $4=(($3+112)|0);
19151   var $5=HEAP32[(($4)>>2)];
19152   var $6=((($5)+(1))|0);
19153   HEAP32[(($4)>>2)]=$6;
19154   var $7=$ap;
19155   HEAP32[(($7)>>2)]=arguments[_qcvmerror.length];
19156   var $8=$2;
19157   var $9=HEAP32[(($ap)>>2)];
19158   var $10=_vprintf($8, $9);
19159   var $11=$ap;
19160   ;
19161   var $12=HEAP32[((_stdout)>>2)];
19162   var $13=_putc(10, $12);
19163   STACKTOP = __stackBase__;
19164   return;
19165 }
19166
19167
19168 function _prog_print_statement($prog, $st) {
19169   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19170   var __label__;
19171   __label__ = 2;
19172   while(1) switch(__label__) {
19173     case 2:
19174       var $1;
19175       var $2;
19176       var $t=__stackBase__;
19177       $1=$prog;
19178       $2=$st;
19179       var $3=$2;
19180       var $4=(($3)|0);
19181       var $5=HEAP16[(($4)>>1)];
19182       var $6=(($5)&65535);
19183       var $7=(($6)>>>0) >= 67;
19184       if ($7) { __label__ = 3; break; } else { __label__ = 4; break; }
19185     case 3:
19186       var $9=$2;
19187       var $10=(($9)|0);
19188       var $11=HEAP16[(($10)>>1)];
19189       var $12=(($11)&65535);
19190       var $13=_printf(((STRING_TABLE.__str27)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$12,tempInt));
19191       __label__ = 42; break;
19192     case 4:
19193       var $15=$2;
19194       var $16=(($15)|0);
19195       var $17=HEAP16[(($16)>>1)];
19196       var $18=(($17)&65535);
19197       var $19=((_asm_instr+($18)*(12))|0);
19198       var $20=(($19)|0);
19199       var $21=HEAP32[(($20)>>2)];
19200       var $22=_printf(((STRING_TABLE.__str28)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$21,tempInt));
19201       var $23=$2;
19202       var $24=(($23)|0);
19203       var $25=HEAP16[(($24)>>1)];
19204       var $26=(($25)&65535);
19205       var $27=(($26)|0) >= 49;
19206       if ($27) { __label__ = 5; break; } else { __label__ = 7; break; }
19207     case 5:
19208       var $29=$2;
19209       var $30=(($29)|0);
19210       var $31=HEAP16[(($30)>>1)];
19211       var $32=(($31)&65535);
19212       var $33=(($32)|0) <= 50;
19213       if ($33) { __label__ = 6; break; } else { __label__ = 7; break; }
19214     case 6:
19215       var $35=$1;
19216       var $36=$2;
19217       var $37=(($36+2)|0);
19218       var $38=$37;
19219       var $39=HEAP16[(($38)>>1)];
19220       var $40=(($39)&65535);
19221       _trace_print_global($35, $40, 2);
19222       var $41=$2;
19223       var $42=(($41+4)|0);
19224       var $43=$42;
19225       var $44=HEAP16[(($43)>>1)];
19226       var $45=(($44 << 16) >> 16);
19227       var $46=_printf(((STRING_TABLE.__str29)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$45,tempInt));
19228       __label__ = 41; break;
19229     case 7:
19230       var $48=$2;
19231       var $49=(($48)|0);
19232       var $50=HEAP16[(($49)>>1)];
19233       var $51=(($50)&65535);
19234       var $52=(($51)|0) >= 51;
19235       if ($52) { __label__ = 8; break; } else { __label__ = 10; break; }
19236     case 8:
19237       var $54=$2;
19238       var $55=(($54)|0);
19239       var $56=HEAP16[(($55)>>1)];
19240       var $57=(($56)&65535);
19241       var $58=(($57)|0) <= 59;
19242       if ($58) { __label__ = 9; break; } else { __label__ = 10; break; }
19243     case 9:
19244       var $60=_printf(((STRING_TABLE.__str30)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19245       __label__ = 40; break;
19246     case 10:
19247       var $62=$2;
19248       var $63=(($62)|0);
19249       var $64=HEAP16[(($63)>>1)];
19250       var $65=(($64)&65535);
19251       var $66=(($65)|0)==61;
19252       if ($66) { __label__ = 11; break; } else { __label__ = 12; break; }
19253     case 11:
19254       var $68=$2;
19255       var $69=(($68+2)|0);
19256       var $70=$69;
19257       var $71=HEAP16[(($70)>>1)];
19258       var $72=(($71 << 16) >> 16);
19259       var $73=_printf(((STRING_TABLE.__str31)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$72,tempInt));
19260       __label__ = 39; break;
19261     case 12:
19262       var $75=$t;
19263       assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($75)>>2)]=HEAP32[((_prog_print_statement_t)>>2)];HEAP32[((($75)+(4))>>2)]=HEAP32[(((_prog_print_statement_t)+(4))>>2)];HEAP32[((($75)+(8))>>2)]=HEAP32[(((_prog_print_statement_t)+(8))>>2)];
19264       var $76=$2;
19265       var $77=(($76)|0);
19266       var $78=HEAP16[(($77)>>1)];
19267       var $79=(($78)&65535);
19268       if ((($79)|0) == 3) {
19269         __label__ = 13; break;
19270       }
19271       else if ((($79)|0) == 4) {
19272         __label__ = 14; break;
19273       }
19274       else if ((($79)|0) == 2) {
19275         __label__ = 15; break;
19276       }
19277       else if ((($79)|0) == 7 || (($79)|0) == 9 || (($79)|0) == 11 || (($79)|0) == 16) {
19278         __label__ = 16; break;
19279       }
19280       else if ((($79)|0) == 12 || (($79)|0) == 17) {
19281         __label__ = 17; break;
19282       }
19283       else if ((($79)|0) == 31 || (($79)|0) == 37) {
19284         __label__ = 18; break;
19285       }
19286       else if ((($79)|0) == 32) {
19287         __label__ = 19; break;
19288       }
19289       else if ((($79)|0) == 33) {
19290         __label__ = 20; break;
19291       }
19292       else if ((($79)|0) == 34) {
19293         __label__ = 21; break;
19294       }
19295       else if ((($79)|0) == 35) {
19296         __label__ = 22; break;
19297       }
19298       else if ((($79)|0) == 36) {
19299         __label__ = 23; break;
19300       }
19301       else if ((($79)|0) == 38) {
19302         __label__ = 24; break;
19303       }
19304       else if ((($79)|0) == 39) {
19305         __label__ = 25; break;
19306       }
19307       else if ((($79)|0) == 40) {
19308         __label__ = 26; break;
19309       }
19310       else if ((($79)|0) == 41) {
19311         __label__ = 27; break;
19312       }
19313       else if ((($79)|0) == 42) {
19314         __label__ = 28; break;
19315       }
19316       else {
19317       __label__ = 29; break;
19318       }
19319
19320     case 13:
19321       var $81=(($t+8)|0);
19322       HEAP32[(($81)>>2)]=3;
19323       var $82=(($t+4)|0);
19324       HEAP32[(($82)>>2)]=3;
19325       __label__ = 29; break;
19326     case 14:
19327       var $84=(($t+8)|0);
19328       HEAP32[(($84)>>2)]=3;
19329       var $85=(($t)|0);
19330       HEAP32[(($85)>>2)]=3;
19331       __label__ = 29; break;
19332     case 15:
19333       var $87=(($t+4)|0);
19334       HEAP32[(($87)>>2)]=3;
19335       var $88=(($t)|0);
19336       HEAP32[(($88)>>2)]=3;
19337       __label__ = 29; break;
19338     case 16:
19339       var $90=(($t+8)|0);
19340       HEAP32[(($90)>>2)]=3;
19341       var $91=(($t+4)|0);
19342       HEAP32[(($91)>>2)]=3;
19343       var $92=(($t)|0);
19344       HEAP32[(($92)>>2)]=3;
19345       __label__ = 29; break;
19346     case 17:
19347       var $94=(($t+4)|0);
19348       HEAP32[(($94)>>2)]=1;
19349       var $95=(($t)|0);
19350       HEAP32[(($95)>>2)]=1;
19351       __label__ = 29; break;
19352     case 18:
19353       var $97=(($t+8)|0);
19354       HEAP32[(($97)>>2)]=-1;
19355       __label__ = 29; break;
19356     case 19:
19357       var $99=(($t+4)|0);
19358       HEAP32[(($99)>>2)]=3;
19359       var $100=(($t)|0);
19360       HEAP32[(($100)>>2)]=3;
19361       var $101=(($t+8)|0);
19362       HEAP32[(($101)>>2)]=-1;
19363       __label__ = 29; break;
19364     case 20:
19365       var $103=(($t+4)|0);
19366       HEAP32[(($103)>>2)]=1;
19367       var $104=(($t)|0);
19368       HEAP32[(($104)>>2)]=1;
19369       var $105=(($t+8)|0);
19370       HEAP32[(($105)>>2)]=-1;
19371       __label__ = 29; break;
19372     case 21:
19373       var $107=(($t+4)|0);
19374       HEAP32[(($107)>>2)]=4;
19375       var $108=(($t)|0);
19376       HEAP32[(($108)>>2)]=4;
19377       var $109=(($t+8)|0);
19378       HEAP32[(($109)>>2)]=-1;
19379       __label__ = 29; break;
19380     case 22:
19381       var $111=(($t+4)|0);
19382       HEAP32[(($111)>>2)]=5;
19383       var $112=(($t)|0);
19384       HEAP32[(($112)>>2)]=5;
19385       var $113=(($t+8)|0);
19386       HEAP32[(($113)>>2)]=-1;
19387       __label__ = 29; break;
19388     case 23:
19389       var $115=(($t+4)|0);
19390       HEAP32[(($115)>>2)]=6;
19391       var $116=(($t)|0);
19392       HEAP32[(($116)>>2)]=6;
19393       var $117=(($t+8)|0);
19394       HEAP32[(($117)>>2)]=-1;
19395       __label__ = 29; break;
19396     case 24:
19397       var $119=(($t)|0);
19398       HEAP32[(($119)>>2)]=3;
19399       var $120=(($t+4)|0);
19400       HEAP32[(($120)>>2)]=4;
19401       var $121=(($t+8)|0);
19402       HEAP32[(($121)>>2)]=-1;
19403       __label__ = 29; break;
19404     case 25:
19405       var $123=(($t)|0);
19406       HEAP32[(($123)>>2)]=1;
19407       var $124=(($t+4)|0);
19408       HEAP32[(($124)>>2)]=4;
19409       var $125=(($t+8)|0);
19410       HEAP32[(($125)>>2)]=-1;
19411       __label__ = 29; break;
19412     case 26:
19413       var $127=(($t)|0);
19414       HEAP32[(($127)>>2)]=4;
19415       var $128=(($t+4)|0);
19416       HEAP32[(($128)>>2)]=4;
19417       var $129=(($t+8)|0);
19418       HEAP32[(($129)>>2)]=-1;
19419       __label__ = 29; break;
19420     case 27:
19421       var $131=(($t)|0);
19422       HEAP32[(($131)>>2)]=5;
19423       var $132=(($t+4)|0);
19424       HEAP32[(($132)>>2)]=4;
19425       var $133=(($t+8)|0);
19426       HEAP32[(($133)>>2)]=-1;
19427       __label__ = 29; break;
19428     case 28:
19429       var $135=(($t)|0);
19430       HEAP32[(($135)>>2)]=6;
19431       var $136=(($t+4)|0);
19432       HEAP32[(($136)>>2)]=4;
19433       var $137=(($t+8)|0);
19434       HEAP32[(($137)>>2)]=-1;
19435       __label__ = 29; break;
19436     case 29:
19437       var $139=(($t)|0);
19438       var $140=HEAP32[(($139)>>2)];
19439       var $141=(($140)|0) >= 0;
19440       if ($141) { __label__ = 30; break; } else { __label__ = 31; break; }
19441     case 30:
19442       var $143=$1;
19443       var $144=$2;
19444       var $145=(($144+2)|0);
19445       var $146=$145;
19446       var $147=HEAP16[(($146)>>1)];
19447       var $148=(($147)&65535);
19448       var $149=(($t)|0);
19449       var $150=HEAP32[(($149)>>2)];
19450       _trace_print_global($143, $148, $150);
19451       __label__ = 32; break;
19452     case 31:
19453       var $152=_printf(((STRING_TABLE.__str32)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19454       __label__ = 32; break;
19455     case 32:
19456       var $154=(($t+4)|0);
19457       var $155=HEAP32[(($154)>>2)];
19458       var $156=(($155)|0) >= 0;
19459       if ($156) { __label__ = 33; break; } else { __label__ = 34; break; }
19460     case 33:
19461       var $158=$1;
19462       var $159=$2;
19463       var $160=(($159+4)|0);
19464       var $161=$160;
19465       var $162=HEAP16[(($161)>>1)];
19466       var $163=(($162)&65535);
19467       var $164=(($t+4)|0);
19468       var $165=HEAP32[(($164)>>2)];
19469       _trace_print_global($158, $163, $165);
19470       __label__ = 35; break;
19471     case 34:
19472       var $167=_printf(((STRING_TABLE.__str32)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19473       __label__ = 35; break;
19474     case 35:
19475       var $169=(($t+8)|0);
19476       var $170=HEAP32[(($169)>>2)];
19477       var $171=(($170)|0) >= 0;
19478       if ($171) { __label__ = 36; break; } else { __label__ = 37; break; }
19479     case 36:
19480       var $173=$1;
19481       var $174=$2;
19482       var $175=(($174+6)|0);
19483       var $176=$175;
19484       var $177=HEAP16[(($176)>>1)];
19485       var $178=(($177)&65535);
19486       var $179=(($t+8)|0);
19487       var $180=HEAP32[(($179)>>2)];
19488       _trace_print_global($173, $178, $180);
19489       __label__ = 38; break;
19490     case 37:
19491       var $182=_printf(((STRING_TABLE.__str33)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19492       __label__ = 38; break;
19493     case 38:
19494       var $184=_printf(((STRING_TABLE.__str30)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19495       __label__ = 39; break;
19496     case 39:
19497       __label__ = 40; break;
19498     case 40:
19499       __label__ = 41; break;
19500     case 41:
19501       var $188=HEAP32[((_stdout)>>2)];
19502       var $189=_fflush($188);
19503       __label__ = 42; break;
19504     case 42:
19505       STACKTOP = __stackBase__;
19506       return;
19507     default: assert(0, "bad label: " + __label__);
19508   }
19509 }
19510 _prog_print_statement["X"]=1;
19511
19512 function _trace_print_global($prog, $glob, $vtype) {
19513   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19514   var __label__;
19515   __label__ = 2;
19516   while(1) switch(__label__) {
19517     case 2:
19518       var $1;
19519       var $2;
19520       var $3;
19521       var $def;
19522       var $value;
19523       var $len;
19524       var $name;
19525       $1=$prog;
19526       $2=$glob;
19527       $3=$vtype;
19528       var $4=$2;
19529       var $5=(($4)|0)!=0;
19530       if ($5) { __label__ = 4; break; } else { __label__ = 3; break; }
19531     case 3:
19532       var $7=_printf(((STRING_TABLE.__str34)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19533       $len=$7;
19534       __label__ = 17; break;
19535     case 4:
19536       var $9=$1;
19537       var $10=$2;
19538       var $11=_prog_getdef($9, $10);
19539       $def=$11;
19540       var $12=$2;
19541       var $13=$1;
19542       var $14=(($13+64)|0);
19543       var $15=HEAP32[(($14)>>2)];
19544       var $16=(($15+($12<<2))|0);
19545       var $17=$16;
19546       $value=$17;
19547       var $18=$def;
19548       var $19=(($18)|0)!=0;
19549       if ($19) { __label__ = 5; break; } else { __label__ = 9; break; }
19550     case 5:
19551       var $21=$1;
19552       var $22=$def;
19553       var $23=(($22+4)|0);
19554       var $24=HEAP32[(($23)>>2)];
19555       var $25=_prog_getstring($21, $24);
19556       $name=$25;
19557       var $26=$name;
19558       var $27=(($26)|0);
19559       var $28=HEAP8[($27)];
19560       var $29=(($28 << 24) >> 24);
19561       var $30=(($29)|0)==35;
19562       if ($30) { __label__ = 6; break; } else { __label__ = 7; break; }
19563     case 6:
19564       var $32=_printf(((STRING_TABLE.__str35)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19565       $len=$32;
19566       __label__ = 8; break;
19567     case 7:
19568       var $34=$name;
19569       var $35=_printf(((STRING_TABLE.__str36)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$34,tempInt));
19570       $len=$35;
19571       __label__ = 8; break;
19572     case 8:
19573       var $37=$def;
19574       var $38=(($37)|0);
19575       var $39=HEAP16[(($38)>>1)];
19576       var $40=(($39)&65535);
19577       $3=$40;
19578       __label__ = 10; break;
19579     case 9:
19580       var $42=$2;
19581       var $43=_printf(((STRING_TABLE.__str37)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$42,tempInt));
19582       $len=$43;
19583       __label__ = 10; break;
19584     case 10:
19585       var $45=$3;
19586       if ((($45)|0) == 0 || (($45)|0) == 4 || (($45)|0) == 5 || (($45)|0) == 6 || (($45)|0) == 7) {
19587         __label__ = 11; break;
19588       }
19589       else if ((($45)|0) == 3) {
19590         __label__ = 12; break;
19591       }
19592       else if ((($45)|0) == 1) {
19593         __label__ = 13; break;
19594       }
19595       else if ((($45)|0) == 2) {
19596         __label__ = 14; break;
19597       }
19598       else {
19599       __label__ = 15; break;
19600       }
19601
19602     case 11:
19603       var $47=$value;
19604       var $48=$47;
19605       var $49=HEAP32[(($48)>>2)];
19606       var $50=_printf(((STRING_TABLE.__str38)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$49,tempInt));
19607       var $51=$len;
19608       var $52=((($51)+($50))|0);
19609       $len=$52;
19610       __label__ = 16; break;
19611     case 12:
19612       var $54=$value;
19613       var $55=$54;
19614       var $56=(($55)|0);
19615       var $57=HEAPF32[(($56)>>2)];
19616       var $58=$57;
19617       var $59=$value;
19618       var $60=$59;
19619       var $61=(($60+4)|0);
19620       var $62=HEAPF32[(($61)>>2)];
19621       var $63=$62;
19622       var $64=$value;
19623       var $65=$64;
19624       var $66=(($65+8)|0);
19625       var $67=HEAPF32[(($66)>>2)];
19626       var $68=$67;
19627       var $69=_printf(((STRING_TABLE.__str39)|0), (tempInt=STACKTOP,STACKTOP += 24,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),(tempDoubleF64[0]=$58,HEAP32[((tempInt)>>2)]=tempDoubleI32[0],HEAP32[(((tempInt)+(4))>>2)]=tempDoubleI32[1]),(tempDoubleF64[0]=$63,HEAP32[(((tempInt)+(8))>>2)]=tempDoubleI32[0],HEAP32[((((tempInt)+(8))+(4))>>2)]=tempDoubleI32[1]),(tempDoubleF64[0]=$68,HEAP32[(((tempInt)+(16))>>2)]=tempDoubleI32[0],HEAP32[((((tempInt)+(16))+(4))>>2)]=tempDoubleI32[1]),tempInt));
19628       var $70=$len;
19629       var $71=((($70)+($69))|0);
19630       $len=$71;
19631       __label__ = 16; break;
19632     case 13:
19633       var $73=$1;
19634       var $74=$value;
19635       var $75=$74;
19636       var $76=HEAP32[(($75)>>2)];
19637       var $77=_prog_getstring($73, $76);
19638       var $78=$len;
19639       var $79=(((29)-($78))|0);
19640       var $80=((($79)-(5))|0);
19641       var $81=_print_escaped_string($77, $80);
19642       var $82=$len;
19643       var $83=((($82)+($81))|0);
19644       $len=$83;
19645       var $84=_printf(((STRING_TABLE.__str40)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19646       var $85=$len;
19647       var $86=((($85)+($84))|0);
19648       $len=$86;
19649       __label__ = 16; break;
19650     case 14:
19651       __label__ = 15; break;
19652     case 15:
19653       var $89=$value;
19654       var $90=$89;
19655       var $91=HEAPF32[(($90)>>2)];
19656       var $92=$91;
19657       var $93=_printf(((STRING_TABLE.__str41)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),(tempDoubleF64[0]=$92,HEAP32[((tempInt)>>2)]=tempDoubleI32[0],HEAP32[(((tempInt)+(4))>>2)]=tempDoubleI32[1]),tempInt));
19658       var $94=$len;
19659       var $95=((($94)+($93))|0);
19660       $len=$95;
19661       __label__ = 16; break;
19662     case 16:
19663       __label__ = 17; break;
19664     case 17:
19665       var $98=$len;
19666       var $99=(($98)>>>0) < 28;
19667       if ($99) { __label__ = 18; break; } else { __label__ = 19; break; }
19668     case 18:
19669       var $101=$len;
19670       var $102=(((28)-($101))|0);
19671       var $103=((STRING_TABLE._trace_print_global_spaces+$102)|0);
19672       HEAP8[($103)]=0;
19673       var $104=_printf(((STRING_TABLE._trace_print_global_spaces)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19674       var $105=$len;
19675       var $106=(((28)-($105))|0);
19676       var $107=((STRING_TABLE._trace_print_global_spaces+$106)|0);
19677       HEAP8[($107)]=32;
19678       __label__ = 19; break;
19679     case 19:
19680       STACKTOP = __stackBase__;
19681       return;
19682     default: assert(0, "bad label: " + __label__);
19683   }
19684 }
19685 _trace_print_global["X"]=1;
19686
19687 function _print_escaped_string($str, $maxlen) {
19688   ;
19689   var __label__;
19690   __label__ = 2;
19691   while(1) switch(__label__) {
19692     case 2:
19693       var $1;
19694       var $2;
19695       var $len;
19696       $1=$str;
19697       $2=$maxlen;
19698       $len=2;
19699       var $3=HEAP32[((_stdout)>>2)];
19700       var $4=_putc(34, $3);
19701       var $5=$2;
19702       var $6=((($5)-(1))|0);
19703       $2=$6;
19704       __label__ = 3; break;
19705     case 3:
19706       var $8=$1;
19707       var $9=HEAP8[($8)];
19708       var $10=(($9 << 24) >> 24)!=0;
19709       if ($10) { __label__ = 4; break; } else { __label__ = 18; break; }
19710     case 4:
19711       var $12=$len;
19712       var $13=$2;
19713       var $14=(($12)>>>0) >= (($13)>>>0);
19714       if ($14) { __label__ = 5; break; } else { __label__ = 6; break; }
19715     case 5:
19716       var $16=HEAP32[((_stdout)>>2)];
19717       var $17=_putc(46, $16);
19718       var $18=HEAP32[((_stdout)>>2)];
19719       var $19=_putc(46, $18);
19720       var $20=HEAP32[((_stdout)>>2)];
19721       var $21=_putc(46, $20);
19722       var $22=$len;
19723       var $23=((($22)+(3))|0);
19724       $len=$23;
19725       __label__ = 18; break;
19726     case 6:
19727       var $25=$1;
19728       var $26=HEAP8[($25)];
19729       var $27=(($26 << 24) >> 24);
19730       if ((($27)|0) == 7) {
19731         __label__ = 7; break;
19732       }
19733       else if ((($27)|0) == 8) {
19734         __label__ = 8; break;
19735       }
19736       else if ((($27)|0) == 13) {
19737         __label__ = 9; break;
19738       }
19739       else if ((($27)|0) == 10) {
19740         __label__ = 10; break;
19741       }
19742       else if ((($27)|0) == 9) {
19743         __label__ = 11; break;
19744       }
19745       else if ((($27)|0) == 12) {
19746         __label__ = 12; break;
19747       }
19748       else if ((($27)|0) == 11) {
19749         __label__ = 13; break;
19750       }
19751       else if ((($27)|0) == 92) {
19752         __label__ = 14; break;
19753       }
19754       else if ((($27)|0) == 34) {
19755         __label__ = 15; break;
19756       }
19757       else {
19758       __label__ = 16; break;
19759       }
19760
19761     case 7:
19762       var $29=$len;
19763       var $30=((($29)+(2))|0);
19764       $len=$30;
19765       var $31=HEAP32[((_stdout)>>2)];
19766       var $32=_putc(92, $31);
19767       var $33=HEAP32[((_stdout)>>2)];
19768       var $34=_putc(97, $33);
19769       __label__ = 17; break;
19770     case 8:
19771       var $36=$len;
19772       var $37=((($36)+(2))|0);
19773       $len=$37;
19774       var $38=HEAP32[((_stdout)>>2)];
19775       var $39=_putc(92, $38);
19776       var $40=HEAP32[((_stdout)>>2)];
19777       var $41=_putc(98, $40);
19778       __label__ = 17; break;
19779     case 9:
19780       var $43=$len;
19781       var $44=((($43)+(2))|0);
19782       $len=$44;
19783       var $45=HEAP32[((_stdout)>>2)];
19784       var $46=_putc(92, $45);
19785       var $47=HEAP32[((_stdout)>>2)];
19786       var $48=_putc(114, $47);
19787       __label__ = 17; break;
19788     case 10:
19789       var $50=$len;
19790       var $51=((($50)+(2))|0);
19791       $len=$51;
19792       var $52=HEAP32[((_stdout)>>2)];
19793       var $53=_putc(92, $52);
19794       var $54=HEAP32[((_stdout)>>2)];
19795       var $55=_putc(110, $54);
19796       __label__ = 17; break;
19797     case 11:
19798       var $57=$len;
19799       var $58=((($57)+(2))|0);
19800       $len=$58;
19801       var $59=HEAP32[((_stdout)>>2)];
19802       var $60=_putc(92, $59);
19803       var $61=HEAP32[((_stdout)>>2)];
19804       var $62=_putc(116, $61);
19805       __label__ = 17; break;
19806     case 12:
19807       var $64=$len;
19808       var $65=((($64)+(2))|0);
19809       $len=$65;
19810       var $66=HEAP32[((_stdout)>>2)];
19811       var $67=_putc(92, $66);
19812       var $68=HEAP32[((_stdout)>>2)];
19813       var $69=_putc(102, $68);
19814       __label__ = 17; break;
19815     case 13:
19816       var $71=$len;
19817       var $72=((($71)+(2))|0);
19818       $len=$72;
19819       var $73=HEAP32[((_stdout)>>2)];
19820       var $74=_putc(92, $73);
19821       var $75=HEAP32[((_stdout)>>2)];
19822       var $76=_putc(118, $75);
19823       __label__ = 17; break;
19824     case 14:
19825       var $78=$len;
19826       var $79=((($78)+(2))|0);
19827       $len=$79;
19828       var $80=HEAP32[((_stdout)>>2)];
19829       var $81=_putc(92, $80);
19830       var $82=HEAP32[((_stdout)>>2)];
19831       var $83=_putc(92, $82);
19832       __label__ = 17; break;
19833     case 15:
19834       var $85=$len;
19835       var $86=((($85)+(2))|0);
19836       $len=$86;
19837       var $87=HEAP32[((_stdout)>>2)];
19838       var $88=_putc(92, $87);
19839       var $89=HEAP32[((_stdout)>>2)];
19840       var $90=_putc(34, $89);
19841       __label__ = 17; break;
19842     case 16:
19843       var $92=$len;
19844       var $93=((($92)+(1))|0);
19845       $len=$93;
19846       var $94=$1;
19847       var $95=HEAP8[($94)];
19848       var $96=(($95 << 24) >> 24);
19849       var $97=HEAP32[((_stdout)>>2)];
19850       var $98=_putc($96, $97);
19851       __label__ = 17; break;
19852     case 17:
19853       var $100=$1;
19854       var $101=(($100+1)|0);
19855       $1=$101;
19856       __label__ = 3; break;
19857     case 18:
19858       var $103=HEAP32[((_stdout)>>2)];
19859       var $104=_putc(34, $103);
19860       var $105=$len;
19861       ;
19862       return $105;
19863     default: assert(0, "bad label: " + __label__);
19864   }
19865 }
19866 _print_escaped_string["X"]=1;
19867
19868 function _prog_enterfunction($prog, $func) {
19869   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19870   var __label__;
19871   __label__ = 2;
19872   while(1) switch(__label__) {
19873     case 2:
19874       var $1;
19875       var $2;
19876       var $st=__stackBase__;
19877       var $p;
19878       var $parampos;
19879       var $globals;
19880       var $s;
19881       $1=$prog;
19882       $2=$func;
19883       var $3=$1;
19884       var $4=(($3+156)|0);
19885       var $5=HEAP32[(($4)>>2)];
19886       var $6=(($st+4)|0);
19887       HEAP32[(($6)>>2)]=$5;
19888       var $7=$1;
19889       var $8=(($7+176)|0);
19890       var $9=HEAP32[(($8)>>2)];
19891       var $10=(($st)|0);
19892       HEAP32[(($10)>>2)]=$9;
19893       var $11=$2;
19894       var $12=(($st+8)|0);
19895       HEAP32[(($12)>>2)]=$11;
19896       var $13=$1;
19897       var $14=(($13+64)|0);
19898       var $15=HEAP32[(($14)>>2)];
19899       var $16=$2;
19900       var $17=(($16+4)|0);
19901       var $18=HEAP32[(($17)>>2)];
19902       var $19=(($15+($18<<2))|0);
19903       $globals=$19;
19904       var $20=$1;
19905       var $21=$globals;
19906       var $22=$2;
19907       var $23=(($22+8)|0);
19908       var $24=HEAP32[(($23)>>2)];
19909       var $25=_qc_program_localstack_append($20, $21, $24);
19910       if ($25) { __label__ = 4; break; } else { __label__ = 3; break; }
19911     case 3:
19912       var $27=_printf(((STRING_TABLE.__str109)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19913       _exit(1);
19914       throw "Reached an unreachable!"
19915     case 4:
19916       var $29=$2;
19917       var $30=(($29+4)|0);
19918       var $31=HEAP32[(($30)>>2)];
19919       $parampos=$31;
19920       $p=0;
19921       __label__ = 5; break;
19922     case 5:
19923       var $33=$p;
19924       var $34=$2;
19925       var $35=(($34+24)|0);
19926       var $36=HEAP32[(($35)>>2)];
19927       var $37=(($33)>>>0) < (($36)>>>0);
19928       if ($37) { __label__ = 6; break; } else { __label__ = 12; break; }
19929     case 6:
19930       $s=0;
19931       __label__ = 7; break;
19932     case 7:
19933       var $40=$s;
19934       var $41=$p;
19935       var $42=$2;
19936       var $43=(($42+28)|0);
19937       var $44=(($43+$41)|0);
19938       var $45=HEAP8[($44)];
19939       var $46=(($45)&255);
19940       var $47=(($40)>>>0) < (($46)>>>0);
19941       if ($47) { __label__ = 8; break; } else { __label__ = 10; break; }
19942     case 8:
19943       var $49=$p;
19944       var $50=((($49)*(3))|0);
19945       var $51=((($50)+(4))|0);
19946       var $52=$s;
19947       var $53=((($51)+($52))|0);
19948       var $54=$1;
19949       var $55=(($54+64)|0);
19950       var $56=HEAP32[(($55)>>2)];
19951       var $57=(($56+($53<<2))|0);
19952       var $58=HEAP32[(($57)>>2)];
19953       var $59=$parampos;
19954       var $60=$1;
19955       var $61=(($60+64)|0);
19956       var $62=HEAP32[(($61)>>2)];
19957       var $63=(($62+($59<<2))|0);
19958       HEAP32[(($63)>>2)]=$58;
19959       var $64=$parampos;
19960       var $65=((($64)+(1))|0);
19961       $parampos=$65;
19962       __label__ = 9; break;
19963     case 9:
19964       var $67=$s;
19965       var $68=((($67)+(1))|0);
19966       $s=$68;
19967       __label__ = 7; break;
19968     case 10:
19969       __label__ = 11; break;
19970     case 11:
19971       var $71=$p;
19972       var $72=((($71)+(1))|0);
19973       $p=$72;
19974       __label__ = 5; break;
19975     case 12:
19976       var $74=$1;
19977       var $75=(($st)|0);
19978       var $76=HEAP32[(($75)>>2)];
19979       var $77=(($st+4)|0);
19980       var $78=HEAP32[(($77)>>2)];
19981       var $79=(($st+8)|0);
19982       var $80=HEAP32[(($79)>>2)];
19983       var $81=_qc_program_stack_add($74, $76, $78, $80);
19984       if ($81) { __label__ = 14; break; } else { __label__ = 13; break; }
19985     case 13:
19986       var $83=_printf(((STRING_TABLE.__str109)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
19987       _exit(1);
19988       throw "Reached an unreachable!"
19989     case 14:
19990       var $85=$2;
19991       var $86=(($85)|0);
19992       var $87=HEAP32[(($86)>>2)];
19993       STACKTOP = __stackBase__;
19994       return $87;
19995     default: assert(0, "bad label: " + __label__);
19996   }
19997 }
19998 _prog_enterfunction["X"]=1;
19999
20000 function _prog_leavefunction($prog) {
20001   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
20002   var __label__;
20003   __label__ = 2;
20004   while(1) switch(__label__) {
20005     case 2:
20006       var $1;
20007       var $prev;
20008       var $oldsp;
20009       var $st=__stackBase__;
20010       var $globals;
20011       $1=$prog;
20012       $prev=0;
20013       var $2=$1;
20014       var $3=(($2+168)|0);
20015       var $4=HEAP32[(($3)>>2)];
20016       var $5=((($4)-(1))|0);
20017       var $6=$1;
20018       var $7=(($6+164)|0);
20019       var $8=HEAP32[(($7)>>2)];
20020       var $9=(($8+($5)*(12))|0);
20021       var $10=$st;
20022       var $11=$9;
20023       assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)];HEAP32[((($10)+(8))>>2)]=HEAP32[((($11)+(8))>>2)];
20024       var $12=$1;
20025       var $13=(($12+168)|0);
20026       var $14=HEAP32[(($13)>>2)];
20027       var $15=((($14)-(1))|0);
20028       var $16=$1;
20029       var $17=(($16+164)|0);
20030       var $18=HEAP32[(($17)>>2)];
20031       var $19=(($18+($15)*(12))|0);
20032       var $20=(($19+8)|0);
20033       var $21=HEAP32[(($20)>>2)];
20034       $prev=$21;
20035       var $22=$1;
20036       var $23=(($22+168)|0);
20037       var $24=HEAP32[(($23)>>2)];
20038       var $25=((($24)-(1))|0);
20039       var $26=$1;
20040       var $27=(($26+164)|0);
20041       var $28=HEAP32[(($27)>>2)];
20042       var $29=(($28+($25)*(12))|0);
20043       var $30=(($29+4)|0);
20044       var $31=HEAP32[(($30)>>2)];
20045       $oldsp=$31;
20046       var $32=$prev;
20047       var $33=(($32)|0)!=0;
20048       if ($33) { __label__ = 3; break; } else { __label__ = 6; break; }
20049     case 3:
20050       var $35=$1;
20051       var $36=(($35+64)|0);
20052       var $37=HEAP32[(($36)>>2)];
20053       var $38=$prev;
20054       var $39=(($38+4)|0);
20055       var $40=HEAP32[(($39)>>2)];
20056       var $41=(($37+($40<<2))|0);
20057       $globals=$41;
20058       var $42=$globals;
20059       var $43=$42;
20060       var $44=$1;
20061       var $45=(($44+152)|0);
20062       var $46=HEAP32[(($45)>>2)];
20063       var $47=$oldsp;
20064       var $48=(($46+($47<<2))|0);
20065       var $49=$48;
20066       var $50=$prev;
20067       var $51=(($50+8)|0);
20068       var $52=HEAP32[(($51)>>2)];
20069       assert($52 % 1 === 0, 'memcpy given ' + $52 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($43, $49, $52, 4);
20070       var $53=$1;
20071       var $54=$oldsp;
20072       var $55=_qc_program_localstack_resize($53, $54);
20073       if ($55) { __label__ = 5; break; } else { __label__ = 4; break; }
20074     case 4:
20075       var $57=_printf(((STRING_TABLE.__str109)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
20076       _exit(1);
20077       throw "Reached an unreachable!"
20078     case 5:
20079       __label__ = 6; break;
20080     case 6:
20081       var $60=$1;
20082       var $61=$1;
20083       var $62=(($61+168)|0);
20084       var $63=HEAP32[(($62)>>2)];
20085       var $64=((($63)-(1))|0);
20086       var $65=_qc_program_stack_remove($60, $64);
20087       if ($65) { __label__ = 8; break; } else { __label__ = 7; break; }
20088     case 7:
20089       var $67=_printf(((STRING_TABLE.__str109)|0), (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt));
20090       _exit(1);
20091       throw "Reached an unreachable!"
20092     case 8:
20093       var $69=(($st)|0);
20094       var $70=HEAP32[(($69)>>2)];
20095       var $71=((($70)-(1))|0);
20096       STACKTOP = __stackBase__;
20097       return $71;
20098     default: assert(0, "bad label: " + __label__);
20099   }
20100 }
20101 _prog_leavefunction["X"]=1;
20102
20103 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
20104 // Note: Some Emscripten settings may limit the speed of the generated code.
20105 // Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
20106 var i64Math = null;
20107
20108
20109   function _memcpy(dest, src, num, align) {
20110       assert(num % 1 === 0, 'memcpy given ' + num + ' bytes to copy. Problem with quantum=1 corrections perhaps?');
20111       if (num >= 20 && src % 2 == dest % 2) {
20112         // This is unaligned, but quite large, and potentially alignable, so work hard to get to aligned settings
20113         if (src % 4 == dest % 4) {
20114           var stop = src + num;
20115           while (src % 4) { // no need to check for stop, since we have large num
20116             HEAP8[dest++] = HEAP8[src++];
20117           }
20118           var src4 = src >> 2, dest4 = dest >> 2, stop4 = stop >> 2;
20119           while (src4 < stop4) {
20120             HEAP32[dest4++] = HEAP32[src4++];
20121           }
20122           src = src4 << 2;
20123           dest = dest4 << 2;
20124           while (src < stop) {
20125             HEAP8[dest++] = HEAP8[src++];
20126           }
20127         } else {
20128           var stop = src + num;
20129           if (src % 2) { // no need to check for stop, since we have large num
20130             HEAP8[dest++] = HEAP8[src++];
20131           }
20132           var src2 = src >> 1, dest2 = dest >> 1, stop2 = stop >> 1;
20133           while (src2 < stop2) {
20134             HEAP16[dest2++] = HEAP16[src2++];
20135           }
20136           src = src2 << 1;
20137           dest = dest2 << 1;
20138           if (src < stop) {
20139             HEAP8[dest++] = HEAP8[src++];
20140           }
20141         }
20142       } else {
20143         while (num--) {
20144           HEAP8[dest++] = HEAP8[src++];
20145         }
20146       }
20147     }var _llvm_memcpy_p0i8_p0i8_i32=_memcpy;
20148 var _util_memory_a; // stub for _util_memory_a
20149 var _util_memory_d; // stub for _util_memory_d
20150 var _util_fopen; // stub for _util_fopen
20151
20152
20153
20154   var ERRNO_CODES={E2BIG:7,EACCES:13,EADDRINUSE:98,EADDRNOTAVAIL:99,EAFNOSUPPORT:97,EAGAIN:11,EALREADY:114,EBADF:9,EBADMSG:74,EBUSY:16,ECANCELED:125,ECHILD:10,ECONNABORTED:103,ECONNREFUSED:111,ECONNRESET:104,EDEADLK:35,EDESTADDRREQ:89,EDOM:33,EDQUOT:122,EEXIST:17,EFAULT:14,EFBIG:27,EHOSTUNREACH:113,EIDRM:43,EILSEQ:84,EINPROGRESS:115,EINTR:4,EINVAL:22,EIO:5,EISCONN:106,EISDIR:21,ELOOP:40,EMFILE:24,EMLINK:31,EMSGSIZE:90,EMULTIHOP:72,ENAMETOOLONG:36,ENETDOWN:100,ENETRESET:102,ENETUNREACH:101,ENFILE:23,ENOBUFS:105,ENODATA:61,ENODEV:19,ENOENT:2,ENOEXEC:8,ENOLCK:37,ENOLINK:67,ENOMEM:12,ENOMSG:42,ENOPROTOOPT:92,ENOSPC:28,ENOSR:63,ENOSTR:60,ENOSYS:38,ENOTCONN:107,ENOTDIR:20,ENOTEMPTY:39,ENOTRECOVERABLE:131,ENOTSOCK:88,ENOTSUP:95,ENOTTY:25,ENXIO:6,EOVERFLOW:75,EOWNERDEAD:130,EPERM:1,EPIPE:32,EPROTO:71,EPROTONOSUPPORT:93,EPROTOTYPE:91,ERANGE:34,EROFS:30,ESPIPE:29,ESRCH:3,ESTALE:116,ETIME:62,ETIMEDOUT:110,ETXTBSY:26,EWOULDBLOCK:11,EXDEV:18};
20155
20156   function ___setErrNo(value) {
20157       // For convenient setting and returning of errno.
20158       if (!___setErrNo.ret) ___setErrNo.ret = allocate([0], 'i32', ALLOC_STATIC);
20159       HEAP32[((___setErrNo.ret)>>2)]=value
20160       return value;
20161     }
20162
20163   var _stdin=0;
20164
20165   var _stdout=0;
20166
20167   var _stderr=0;
20168
20169   var __impure_ptr=0;var FS={currentPath:"/",nextInode:2,streams:[null],checkStreams:function () {
20170         for (var i in FS.streams) assert(i >= 0 && i < FS.streams.length); // no keys not in dense span
20171         for (var i = 0; i < FS.streams.length; i++) assert(typeof FS.streams[i] == 'object'); // no non-null holes in dense span
20172       },ignorePermissions:true,joinPath:function (parts, forceRelative) {
20173         var ret = parts[0];
20174         for (var i = 1; i < parts.length; i++) {
20175           if (ret[ret.length-1] != '/') ret += '/';
20176           ret += parts[i];
20177         }
20178         if (forceRelative && ret[0] == '/') ret = ret.substr(1);
20179         return ret;
20180       },absolutePath:function (relative, base) {
20181         if (typeof relative !== 'string') return null;
20182         if (base === undefined) base = FS.currentPath;
20183         if (relative && relative[0] == '/') base = '';
20184         var full = base + '/' + relative;
20185         var parts = full.split('/').reverse();
20186         var absolute = [''];
20187         while (parts.length) {
20188           var part = parts.pop();
20189           if (part == '' || part == '.') {
20190             // Nothing.
20191           } else if (part == '..') {
20192             if (absolute.length > 1) absolute.pop();
20193           } else {
20194             absolute.push(part);
20195           }
20196         }
20197         return absolute.length == 1 ? '/' : absolute.join('/');
20198       },analyzePath:function (path, dontResolveLastLink, linksVisited) {
20199         var ret = {
20200           isRoot: false,
20201           exists: false,
20202           error: 0,
20203           name: null,
20204           path: null,
20205           object: null,
20206           parentExists: false,
20207           parentPath: null,
20208           parentObject: null
20209         };
20210         path = FS.absolutePath(path);
20211         if (path == '/') {
20212           ret.isRoot = true;
20213           ret.exists = ret.parentExists = true;
20214           ret.name = '/';
20215           ret.path = ret.parentPath = '/';
20216           ret.object = ret.parentObject = FS.root;
20217         } else if (path !== null) {
20218           linksVisited = linksVisited || 0;
20219           path = path.slice(1).split('/');
20220           var current = FS.root;
20221           var traversed = [''];
20222           while (path.length) {
20223             if (path.length == 1 && current.isFolder) {
20224               ret.parentExists = true;
20225               ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/');
20226               ret.parentObject = current;
20227               ret.name = path[0];
20228             }
20229             var target = path.shift();
20230             if (!current.isFolder) {
20231               ret.error = ERRNO_CODES.ENOTDIR;
20232               break;
20233             } else if (!current.read) {
20234               ret.error = ERRNO_CODES.EACCES;
20235               break;
20236             } else if (!current.contents.hasOwnProperty(target)) {
20237               ret.error = ERRNO_CODES.ENOENT;
20238               break;
20239             }
20240             current = current.contents[target];
20241             if (current.link && !(dontResolveLastLink && path.length == 0)) {
20242               if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX.
20243                 ret.error = ERRNO_CODES.ELOOP;
20244                 break;
20245               }
20246               var link = FS.absolutePath(current.link, traversed.join('/'));
20247               ret = FS.analyzePath([link].concat(path).join('/'),
20248                                    dontResolveLastLink, linksVisited + 1);
20249               return ret;
20250             }
20251             traversed.push(target);
20252             if (path.length == 0) {
20253               ret.exists = true;
20254               ret.path = traversed.join('/');
20255               ret.object = current;
20256             }
20257           }
20258         }
20259         return ret;
20260       },findObject:function (path, dontResolveLastLink) {
20261         FS.ensureRoot();
20262         var ret = FS.analyzePath(path, dontResolveLastLink);
20263         if (ret.exists) {
20264           return ret.object;
20265         } else {
20266           ___setErrNo(ret.error);
20267           return null;
20268         }
20269       },createObject:function (parent, name, properties, canRead, canWrite) {
20270         if (!parent) parent = '/';
20271         if (typeof parent === 'string') parent = FS.findObject(parent);
20272
20273         if (!parent) {
20274           ___setErrNo(ERRNO_CODES.EACCES);
20275           throw new Error('Parent path must exist.');
20276         }
20277         if (!parent.isFolder) {
20278           ___setErrNo(ERRNO_CODES.ENOTDIR);
20279           throw new Error('Parent must be a folder.');
20280         }
20281         if (!parent.write && !FS.ignorePermissions) {
20282           ___setErrNo(ERRNO_CODES.EACCES);
20283           throw new Error('Parent folder must be writeable.');
20284         }
20285         if (!name || name == '.' || name == '..') {
20286           ___setErrNo(ERRNO_CODES.ENOENT);
20287           throw new Error('Name must not be empty.');
20288         }
20289         if (parent.contents.hasOwnProperty(name)) {
20290           ___setErrNo(ERRNO_CODES.EEXIST);
20291           throw new Error("Can't overwrite object.");
20292         }
20293
20294         parent.contents[name] = {
20295           read: canRead === undefined ? true : canRead,
20296           write: canWrite === undefined ? false : canWrite,
20297           timestamp: Date.now(),
20298           inodeNumber: FS.nextInode++
20299         };
20300         for (var key in properties) {
20301           if (properties.hasOwnProperty(key)) {
20302             parent.contents[name][key] = properties[key];
20303           }
20304         }
20305
20306         return parent.contents[name];
20307       },createFolder:function (parent, name, canRead, canWrite) {
20308         var properties = {isFolder: true, isDevice: false, contents: {}};
20309         return FS.createObject(parent, name, properties, canRead, canWrite);
20310       },createPath:function (parent, path, canRead, canWrite) {
20311         var current = FS.findObject(parent);
20312         if (current === null) throw new Error('Invalid parent.');
20313         path = path.split('/').reverse();
20314         while (path.length) {
20315           var part = path.pop();
20316           if (!part) continue;
20317           if (!current.contents.hasOwnProperty(part)) {
20318             FS.createFolder(current, part, canRead, canWrite);
20319           }
20320           current = current.contents[part];
20321         }
20322         return current;
20323       },createFile:function (parent, name, properties, canRead, canWrite) {
20324         properties.isFolder = false;
20325         return FS.createObject(parent, name, properties, canRead, canWrite);
20326       },createDataFile:function (parent, name, data, canRead, canWrite) {
20327         if (typeof data === 'string') {
20328           var dataArray = new Array(data.length);
20329           for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i);
20330           data = dataArray;
20331         }
20332         var properties = {
20333           isDevice: false,
20334           contents: data.subarray ? data.subarray(0) : data // as an optimization, create a new array wrapper (not buffer) here, to help JS engines understand this object
20335         };
20336         return FS.createFile(parent, name, properties, canRead, canWrite);
20337       },createLazyFile:function (parent, name, url, canRead, canWrite) {
20338
20339         if (typeof XMLHttpRequest !== 'undefined') {
20340           if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
20341           // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
20342           var LazyUint8Array = function(chunkSize, length) {
20343             this.length = length;
20344             this.chunkSize = chunkSize;
20345             this.chunks = []; // Loaded chunks. Index is the chunk number
20346           }
20347           LazyUint8Array.prototype.get = function(idx) {
20348             if (idx > this.length-1 || idx < 0) {
20349               return undefined;
20350             }
20351             var chunkOffset = idx % chunkSize;
20352             var chunkNum = Math.floor(idx / chunkSize);
20353             return this.getter(chunkNum)[chunkOffset];
20354           }
20355           LazyUint8Array.prototype.setDataGetter = function(getter) {
20356             this.getter = getter;
20357           }
20358
20359           // Find length
20360           var xhr = new XMLHttpRequest();
20361           xhr.open('HEAD', url, false);
20362           xhr.send(null);
20363           if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
20364           var datalength = Number(xhr.getResponseHeader("Content-length"));
20365           var header;
20366           var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
20367           var chunkSize = 1024*1024; // Chunk size in bytes
20368           if (!hasByteServing) chunkSize = datalength;
20369
20370           // Function to get a range from the remote URL.
20371           var doXHR = (function(from, to) {
20372             if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
20373             if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
20374
20375             // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
20376             var xhr = new XMLHttpRequest();
20377             xhr.open('GET', url, false);
20378             if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
20379
20380             // Some hints to the browser that we want binary data.
20381             if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
20382             if (xhr.overrideMimeType) {
20383               xhr.overrideMimeType('text/plain; charset=x-user-defined');
20384             }
20385
20386             xhr.send(null);
20387             if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
20388             if (xhr.response !== undefined) {
20389               return new Uint8Array(xhr.response || []);
20390             } else {
20391               return intArrayFromString(xhr.responseText || '', true);
20392             }
20393           });
20394
20395           var lazyArray = new LazyUint8Array(chunkSize, datalength);
20396           lazyArray.setDataGetter(function(chunkNum) {
20397             var start = chunkNum * lazyArray.chunkSize;
20398             var end = (chunkNum+1) * lazyArray.chunkSize - 1; // including this byte
20399             end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
20400             if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
20401               lazyArray.chunks[chunkNum] = doXHR(start, end);
20402             }
20403             if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
20404             return lazyArray.chunks[chunkNum];
20405           });
20406           var properties = { isDevice: false, contents: lazyArray };
20407         } else {
20408           var properties = { isDevice: false, url: url };
20409         }
20410
20411         return FS.createFile(parent, name, properties, canRead, canWrite);
20412       },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) {
20413         Browser.ensureObjects();
20414         var fullname = FS.joinPath([parent, name], true);
20415         function processData(byteArray) {
20416           function finish(byteArray) {
20417             if (!dontCreateFile) {
20418               FS.createDataFile(parent, name, byteArray, canRead, canWrite);
20419             }
20420             if (onload) onload();
20421             removeRunDependency('cp ' + fullname);
20422           }
20423           var handled = false;
20424           Module['preloadPlugins'].forEach(function(plugin) {
20425             if (handled) return;
20426             if (plugin['canHandle'](fullname)) {
20427               plugin['handle'](byteArray, fullname, finish, function() {
20428                 if (onerror) onerror();
20429                 removeRunDependency('cp ' + fullname);
20430               });
20431               handled = true;
20432             }
20433           });
20434           if (!handled) finish(byteArray);
20435         }
20436         addRunDependency('cp ' + fullname);
20437         if (typeof url == 'string') {
20438           Browser.asyncLoad(url, function(byteArray) {
20439             processData(byteArray);
20440           }, onerror);
20441         } else {
20442           processData(url);
20443         }
20444       },createLink:function (parent, name, target, canRead, canWrite) {
20445         var properties = {isDevice: false, link: target};
20446         return FS.createFile(parent, name, properties, canRead, canWrite);
20447       },createDevice:function (parent, name, input, output) {
20448         if (!(input || output)) {
20449           throw new Error('A device must have at least one callback defined.');
20450         }
20451         var ops = {isDevice: true, input: input, output: output};
20452         return FS.createFile(parent, name, ops, Boolean(input), Boolean(output));
20453       },forceLoadFile:function (obj) {
20454         if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
20455         var success = true;
20456         if (typeof XMLHttpRequest !== 'undefined') {
20457           throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
20458         } else if (Module['read']) {
20459           // Command-line.
20460           try {
20461             // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
20462             //          read() will try to parse UTF8.
20463             obj.contents = intArrayFromString(Module['read'](obj.url), true);
20464           } catch (e) {
20465             success = false;
20466           }
20467         } else {
20468           throw new Error('Cannot load without read() or XMLHttpRequest.');
20469         }
20470         if (!success) ___setErrNo(ERRNO_CODES.EIO);
20471         return success;
20472       },ensureRoot:function () {
20473         if (FS.root) return;
20474         // The main file system tree. All the contents are inside this.
20475         FS.root = {
20476           read: true,
20477           write: true,
20478           isFolder: true,
20479           isDevice: false,
20480           timestamp: Date.now(),
20481           inodeNumber: 1,
20482           contents: {}
20483         };
20484       },init:function (input, output, error) {
20485         // Make sure we initialize only once.
20486         assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
20487         FS.init.initialized = true;
20488
20489         FS.ensureRoot();
20490
20491         // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
20492         input = input || Module['stdin'];
20493         output = output || Module['stdout'];
20494         error = error || Module['stderr'];
20495
20496         // Default handlers.
20497         var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true;
20498         if (!input) {
20499           stdinOverridden = false;
20500           input = function() {
20501             if (!input.cache || !input.cache.length) {
20502               var result;
20503               if (typeof window != 'undefined' &&
20504                   typeof window.prompt == 'function') {
20505                 // Browser.
20506                 result = window.prompt('Input: ');
20507                 if (result === null) result = String.fromCharCode(0); // cancel ==> EOF
20508               } else if (typeof readline == 'function') {
20509                 // Command line.
20510                 result = readline();
20511               }
20512               if (!result) result = '';
20513               input.cache = intArrayFromString(result + '\n', true);
20514             }
20515             return input.cache.shift();
20516           };
20517         }
20518         var utf8 = new Runtime.UTF8Processor();
20519         function simpleOutput(val) {
20520           if (val === null || val === '\n'.charCodeAt(0)) {
20521             output.printer(output.buffer.join(''));
20522             output.buffer = [];
20523           } else {
20524             output.buffer.push(utf8.processCChar(val));
20525           }
20526         }
20527         if (!output) {
20528           stdoutOverridden = false;
20529           output = simpleOutput;
20530         }
20531         if (!output.printer) output.printer = Module['print'];
20532         if (!output.buffer) output.buffer = [];
20533         if (!error) {
20534           stderrOverridden = false;
20535           error = simpleOutput;
20536         }
20537         if (!error.printer) error.printer = Module['print'];
20538         if (!error.buffer) error.buffer = [];
20539
20540         // Create the temporary folder, if not already created
20541         try {
20542           FS.createFolder('/', 'tmp', true, true);
20543         } catch(e) {}
20544
20545         // Create the I/O devices.
20546         var devFolder = FS.createFolder('/', 'dev', true, true);
20547         var stdin = FS.createDevice(devFolder, 'stdin', input);
20548         var stdout = FS.createDevice(devFolder, 'stdout', null, output);
20549         var stderr = FS.createDevice(devFolder, 'stderr', null, error);
20550         FS.createDevice(devFolder, 'tty', input, output);
20551
20552         // Create default streams.
20553         FS.streams[1] = {
20554           path: '/dev/stdin',
20555           object: stdin,
20556           position: 0,
20557           isRead: true,
20558           isWrite: false,
20559           isAppend: false,
20560           isTerminal: !stdinOverridden,
20561           error: false,
20562           eof: false,
20563           ungotten: []
20564         };
20565         FS.streams[2] = {
20566           path: '/dev/stdout',
20567           object: stdout,
20568           position: 0,
20569           isRead: false,
20570           isWrite: true,
20571           isAppend: false,
20572           isTerminal: !stdoutOverridden,
20573           error: false,
20574           eof: false,
20575           ungotten: []
20576         };
20577         FS.streams[3] = {
20578           path: '/dev/stderr',
20579           object: stderr,
20580           position: 0,
20581           isRead: false,
20582           isWrite: true,
20583           isAppend: false,
20584           isTerminal: !stderrOverridden,
20585           error: false,
20586           eof: false,
20587           ungotten: []
20588         };
20589         // Allocate these on the stack (and never free, we are called from ATINIT or earlier), to keep their locations low
20590         _stdin = allocate([1], 'void*', ALLOC_STACK);
20591         _stdout = allocate([2], 'void*', ALLOC_STACK);
20592         _stderr = allocate([3], 'void*', ALLOC_STACK);
20593
20594         // Other system paths
20595         FS.createPath('/', 'dev/shm/tmp', true, true); // temp files
20596
20597         // Newlib initialization
20598         for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + 4; i++) {
20599           FS.streams[i] = null; // Make sure to keep FS.streams dense
20600         }
20601         FS.streams[_stdin] = FS.streams[1];
20602         FS.streams[_stdout] = FS.streams[2];
20603         FS.streams[_stderr] = FS.streams[3];
20604         FS.checkStreams();
20605         assert(FS.streams.length < 1024); // at this early stage, we should not have a large set of file descriptors - just a few
20606         __impure_ptr = allocate([ allocate(
20607           [0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0],
20608           'void*', ALLOC_STATIC) ], 'void*', ALLOC_STATIC);
20609       },quit:function () {
20610         if (!FS.init.initialized) return;
20611         // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed
20612         if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output('\n'.charCodeAt(0));
20613         if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output('\n'.charCodeAt(0));
20614       },standardizePath:function (path) {
20615         if (path.substr(0, 2) == './') path = path.substr(2);
20616         return path;
20617       },deleteFile:function (path) {
20618         var path = FS.analyzePath(path);
20619         if (!path.parentExists || !path.exists) {
20620           throw 'Invalid path ' + path;
20621         }
20622         delete path.parentObject.contents[path.name];
20623       }};
20624
20625
20626   function _pread(fildes, buf, nbyte, offset) {
20627       // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
20628       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
20629       var stream = FS.streams[fildes];
20630       if (!stream || stream.object.isDevice) {
20631         ___setErrNo(ERRNO_CODES.EBADF);
20632         return -1;
20633       } else if (!stream.isRead) {
20634         ___setErrNo(ERRNO_CODES.EACCES);
20635         return -1;
20636       } else if (stream.object.isFolder) {
20637         ___setErrNo(ERRNO_CODES.EISDIR);
20638         return -1;
20639       } else if (nbyte < 0 || offset < 0) {
20640         ___setErrNo(ERRNO_CODES.EINVAL);
20641         return -1;
20642       } else {
20643         var bytesRead = 0;
20644         while (stream.ungotten.length && nbyte > 0) {
20645           HEAP8[(buf++)]=stream.ungotten.pop()
20646           nbyte--;
20647           bytesRead++;
20648         }
20649         var contents = stream.object.contents;
20650         var size = Math.min(contents.length - offset, nbyte);
20651         if (contents.subarray || contents.slice) { // typed array or normal array
20652           for (var i = 0; i < size; i++) {
20653             HEAP8[((buf)+(i))]=contents[offset + i]
20654           }
20655         } else {
20656           for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
20657             HEAP8[((buf)+(i))]=contents.get(offset + i)
20658           }
20659         }
20660         bytesRead += size;
20661         return bytesRead;
20662       }
20663     }function _read(fildes, buf, nbyte) {
20664       // ssize_t read(int fildes, void *buf, size_t nbyte);
20665       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
20666       var stream = FS.streams[fildes];
20667       if (!stream) {
20668         ___setErrNo(ERRNO_CODES.EBADF);
20669         return -1;
20670       } else if (!stream.isRead) {
20671         ___setErrNo(ERRNO_CODES.EACCES);
20672         return -1;
20673       } else if (nbyte < 0) {
20674         ___setErrNo(ERRNO_CODES.EINVAL);
20675         return -1;
20676       } else {
20677         var bytesRead;
20678         if (stream.object.isDevice) {
20679           if (stream.object.input) {
20680             bytesRead = 0;
20681             while (stream.ungotten.length && nbyte > 0) {
20682               HEAP8[(buf++)]=stream.ungotten.pop()
20683               nbyte--;
20684               bytesRead++;
20685             }
20686             for (var i = 0; i < nbyte; i++) {
20687               try {
20688                 var result = stream.object.input();
20689               } catch (e) {
20690                 ___setErrNo(ERRNO_CODES.EIO);
20691                 return -1;
20692               }
20693               if (result === null || result === undefined) break;
20694               bytesRead++;
20695               HEAP8[((buf)+(i))]=result
20696             }
20697             return bytesRead;
20698           } else {
20699             ___setErrNo(ERRNO_CODES.ENXIO);
20700             return -1;
20701           }
20702         } else {
20703           var ungotSize = stream.ungotten.length;
20704           bytesRead = _pread(fildes, buf, nbyte, stream.position);
20705           if (bytesRead != -1) {
20706             stream.position += (stream.ungotten.length - ungotSize) + bytesRead;
20707           }
20708           return bytesRead;
20709         }
20710       }
20711     }function _fread(ptr, size, nitems, stream) {
20712       // size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
20713       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html
20714       var bytesToRead = nitems * size;
20715       if (bytesToRead == 0) return 0;
20716       var bytesRead = _read(stream, ptr, bytesToRead);
20717       var streamObj = FS.streams[stream];
20718       if (bytesRead == -1) {
20719         if (streamObj) streamObj.error = true;
20720         return 0;
20721       } else {
20722         if (bytesRead < bytesToRead) streamObj.eof = true;
20723         return Math.floor(bytesRead / size);
20724       }
20725     }
20726
20727
20728   function _close(fildes) {
20729       // int close(int fildes);
20730       // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html
20731       if (FS.streams[fildes]) {
20732         if (FS.streams[fildes].currentEntry) {
20733           _free(FS.streams[fildes].currentEntry);
20734         }
20735         FS.streams[fildes] = null;
20736         return 0;
20737       } else {
20738         ___setErrNo(ERRNO_CODES.EBADF);
20739         return -1;
20740       }
20741     }
20742
20743   function _fsync(fildes) {
20744       // int fsync(int fildes);
20745       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html
20746       if (FS.streams[fildes]) {
20747         // We write directly to the file system, so there's nothing to do here.
20748         return 0;
20749       } else {
20750         ___setErrNo(ERRNO_CODES.EBADF);
20751         return -1;
20752       }
20753     }function _fclose(stream) {
20754       // int fclose(FILE *stream);
20755       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html
20756       _fsync(stream);
20757       return _close(stream);
20758     }
20759
20760
20761
20762
20763
20764   function _pwrite(fildes, buf, nbyte, offset) {
20765       // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
20766       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
20767       var stream = FS.streams[fildes];
20768       if (!stream || stream.object.isDevice) {
20769         ___setErrNo(ERRNO_CODES.EBADF);
20770         return -1;
20771       } else if (!stream.isWrite) {
20772         ___setErrNo(ERRNO_CODES.EACCES);
20773         return -1;
20774       } else if (stream.object.isFolder) {
20775         ___setErrNo(ERRNO_CODES.EISDIR);
20776         return -1;
20777       } else if (nbyte < 0 || offset < 0) {
20778         ___setErrNo(ERRNO_CODES.EINVAL);
20779         return -1;
20780       } else {
20781         var contents = stream.object.contents;
20782         while (contents.length < offset) contents.push(0);
20783         for (var i = 0; i < nbyte; i++) {
20784           contents[offset + i] = HEAPU8[((buf)+(i))];
20785         }
20786         stream.object.timestamp = Date.now();
20787         return i;
20788       }
20789     }function _write(fildes, buf, nbyte) {
20790       // ssize_t write(int fildes, const void *buf, size_t nbyte);
20791       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
20792       var stream = FS.streams[fildes];
20793       if (!stream) {
20794         ___setErrNo(ERRNO_CODES.EBADF);
20795         return -1;
20796       } else if (!stream.isWrite) {
20797         ___setErrNo(ERRNO_CODES.EACCES);
20798         return -1;
20799       } else if (nbyte < 0) {
20800         ___setErrNo(ERRNO_CODES.EINVAL);
20801         return -1;
20802       } else {
20803         if (stream.object.isDevice) {
20804           if (stream.object.output) {
20805             for (var i = 0; i < nbyte; i++) {
20806               try {
20807                 stream.object.output(HEAP8[((buf)+(i))]);
20808               } catch (e) {
20809                 ___setErrNo(ERRNO_CODES.EIO);
20810                 return -1;
20811               }
20812             }
20813             stream.object.timestamp = Date.now();
20814             return i;
20815           } else {
20816             ___setErrNo(ERRNO_CODES.ENXIO);
20817             return -1;
20818           }
20819         } else {
20820           var bytesWritten = _pwrite(fildes, buf, nbyte, stream.position);
20821           if (bytesWritten != -1) stream.position += bytesWritten;
20822           return bytesWritten;
20823         }
20824       }
20825     }function _fwrite(ptr, size, nitems, stream) {
20826       // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
20827       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
20828       var bytesToWrite = nitems * size;
20829       if (bytesToWrite == 0) return 0;
20830       var bytesWritten = _write(stream, ptr, bytesToWrite);
20831       if (bytesWritten == -1) {
20832         if (FS.streams[stream]) FS.streams[stream].error = true;
20833         return 0;
20834       } else {
20835         return Math.floor(bytesWritten / size);
20836       }
20837     }
20838
20839   function __formatString(format, varargs) {
20840       var textIndex = format;
20841       var argIndex = 0;
20842       function getNextArg(type) {
20843         // NOTE: Explicitly ignoring type safety. Otherwise this fails:
20844         //       int x = 4; printf("%c\n", (char)x);
20845         var ret;
20846         if (type === 'double') {
20847           ret = (tempDoubleI32[0]=HEAP32[(((varargs)+(argIndex))>>2)],tempDoubleI32[1]=HEAP32[(((varargs)+((argIndex)+(4)))>>2)],tempDoubleF64[0]);
20848         } else if (type == 'i64') {
20849           ret = [HEAP32[(((varargs)+(argIndex))>>2)],
20850                  HEAP32[(((varargs)+(argIndex+4))>>2)]];
20851         } else {
20852           type = 'i32'; // varargs are always i32, i64, or double
20853           ret = HEAP32[(((varargs)+(argIndex))>>2)];
20854         }
20855         argIndex += Runtime.getNativeFieldSize(type);
20856         return ret;
20857       }
20858
20859       var ret = [];
20860       var curr, next, currArg;
20861       while(1) {
20862         var startTextIndex = textIndex;
20863         curr = HEAP8[(textIndex)];
20864         if (curr === 0) break;
20865         next = HEAP8[(textIndex+1)];
20866         if (curr == '%'.charCodeAt(0)) {
20867           // Handle flags.
20868           var flagAlwaysSigned = false;
20869           var flagLeftAlign = false;
20870           var flagAlternative = false;
20871           var flagZeroPad = false;
20872           flagsLoop: while (1) {
20873             switch (next) {
20874               case '+'.charCodeAt(0):
20875                 flagAlwaysSigned = true;
20876                 break;
20877               case '-'.charCodeAt(0):
20878                 flagLeftAlign = true;
20879                 break;
20880               case '#'.charCodeAt(0):
20881                 flagAlternative = true;
20882                 break;
20883               case '0'.charCodeAt(0):
20884                 if (flagZeroPad) {
20885                   break flagsLoop;
20886                 } else {
20887                   flagZeroPad = true;
20888                   break;
20889                 }
20890               default:
20891                 break flagsLoop;
20892             }
20893             textIndex++;
20894             next = HEAP8[(textIndex+1)];
20895           }
20896
20897           // Handle width.
20898           var width = 0;
20899           if (next == '*'.charCodeAt(0)) {
20900             width = getNextArg('i32');
20901             textIndex++;
20902             next = HEAP8[(textIndex+1)];
20903           } else {
20904             while (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) {
20905               width = width * 10 + (next - '0'.charCodeAt(0));
20906               textIndex++;
20907               next = HEAP8[(textIndex+1)];
20908             }
20909           }
20910
20911           // Handle precision.
20912           var precisionSet = false;
20913           if (next == '.'.charCodeAt(0)) {
20914             var precision = 0;
20915             precisionSet = true;
20916             textIndex++;
20917             next = HEAP8[(textIndex+1)];
20918             if (next == '*'.charCodeAt(0)) {
20919               precision = getNextArg('i32');
20920               textIndex++;
20921             } else {
20922               while(1) {
20923                 var precisionChr = HEAP8[(textIndex+1)];
20924                 if (precisionChr < '0'.charCodeAt(0) ||
20925                     precisionChr > '9'.charCodeAt(0)) break;
20926                 precision = precision * 10 + (precisionChr - '0'.charCodeAt(0));
20927                 textIndex++;
20928               }
20929             }
20930             next = HEAP8[(textIndex+1)];
20931           } else {
20932             var precision = 6; // Standard default.
20933           }
20934
20935           // Handle integer sizes. WARNING: These assume a 32-bit architecture!
20936           var argSize;
20937           switch (String.fromCharCode(next)) {
20938             case 'h':
20939               var nextNext = HEAP8[(textIndex+2)];
20940               if (nextNext == 'h'.charCodeAt(0)) {
20941                 textIndex++;
20942                 argSize = 1; // char (actually i32 in varargs)
20943               } else {
20944                 argSize = 2; // short (actually i32 in varargs)
20945               }
20946               break;
20947             case 'l':
20948               var nextNext = HEAP8[(textIndex+2)];
20949               if (nextNext == 'l'.charCodeAt(0)) {
20950                 textIndex++;
20951                 argSize = 8; // long long
20952               } else {
20953                 argSize = 4; // long
20954               }
20955               break;
20956             case 'L': // long long
20957             case 'q': // int64_t
20958             case 'j': // intmax_t
20959               argSize = 8;
20960               break;
20961             case 'z': // size_t
20962             case 't': // ptrdiff_t
20963             case 'I': // signed ptrdiff_t or unsigned size_t
20964               argSize = 4;
20965               break;
20966             default:
20967               argSize = null;
20968           }
20969           if (argSize) textIndex++;
20970           next = HEAP8[(textIndex+1)];
20971
20972           // Handle type specifier.
20973           if (['d', 'i', 'u', 'o', 'x', 'X', 'p'].indexOf(String.fromCharCode(next)) != -1) {
20974             // Integer.
20975             var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0);
20976             argSize = argSize || 4;
20977             var currArg = getNextArg('i' + (argSize * 8));
20978             var origArg = currArg;
20979             var argText;
20980             // Flatten i64-1 [low, high] into a (slightly rounded) double
20981             if (argSize == 8) {
20982               currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0));
20983             }
20984             // Truncate to requested size.
20985             if (argSize <= 4) {
20986               var limit = Math.pow(256, argSize) - 1;
20987               currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
20988             }
20989             // Format the number.
20990             var currAbsArg = Math.abs(currArg);
20991             var prefix = '';
20992             if (next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0)) {
20993               if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1]); else
20994               argText = reSign(currArg, 8 * argSize, 1).toString(10);
20995             } else if (next == 'u'.charCodeAt(0)) {
20996               if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
20997               argText = unSign(currArg, 8 * argSize, 1).toString(10);
20998               currArg = Math.abs(currArg);
20999             } else if (next == 'o'.charCodeAt(0)) {
21000               argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
21001             } else if (next == 'x'.charCodeAt(0) || next == 'X'.charCodeAt(0)) {
21002               prefix = flagAlternative ? '0x' : '';
21003               if (currArg < 0) {
21004                 // Represent negative numbers in hex as 2's complement.
21005                 currArg = -currArg;
21006                 argText = (currAbsArg - 1).toString(16);
21007                 var buffer = [];
21008                 for (var i = 0; i < argText.length; i++) {
21009                   buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
21010                 }
21011                 argText = buffer.join('');
21012                 while (argText.length < argSize * 2) argText = 'f' + argText;
21013               } else {
21014                 argText = currAbsArg.toString(16);
21015               }
21016               if (next == 'X'.charCodeAt(0)) {
21017                 prefix = prefix.toUpperCase();
21018                 argText = argText.toUpperCase();
21019               }
21020             } else if (next == 'p'.charCodeAt(0)) {
21021               if (currAbsArg === 0) {
21022                 argText = '(nil)';
21023               } else {
21024                 prefix = '0x';
21025                 argText = currAbsArg.toString(16);
21026               }
21027             }
21028             if (precisionSet) {
21029               while (argText.length < precision) {
21030                 argText = '0' + argText;
21031               }
21032             }
21033
21034             // Add sign if needed
21035             if (flagAlwaysSigned) {
21036               if (currArg < 0) {
21037                 prefix = '-' + prefix;
21038               } else {
21039                 prefix = '+' + prefix;
21040               }
21041             }
21042
21043             // Add padding.
21044             while (prefix.length + argText.length < width) {
21045               if (flagLeftAlign) {
21046                 argText += ' ';
21047               } else {
21048                 if (flagZeroPad) {
21049                   argText = '0' + argText;
21050                 } else {
21051                   prefix = ' ' + prefix;
21052                 }
21053               }
21054             }
21055
21056             // Insert the result into the buffer.
21057             argText = prefix + argText;
21058             argText.split('').forEach(function(chr) {
21059               ret.push(chr.charCodeAt(0));
21060             });
21061           } else if (['f', 'F', 'e', 'E', 'g', 'G'].indexOf(String.fromCharCode(next)) != -1) {
21062             // Float.
21063             var currArg = getNextArg('double');
21064             var argText;
21065
21066             if (isNaN(currArg)) {
21067               argText = 'nan';
21068               flagZeroPad = false;
21069             } else if (!isFinite(currArg)) {
21070               argText = (currArg < 0 ? '-' : '') + 'inf';
21071               flagZeroPad = false;
21072             } else {
21073               var isGeneral = false;
21074               var effectivePrecision = Math.min(precision, 20);
21075
21076               // Convert g/G to f/F or e/E, as per:
21077               // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
21078               if (next == 'g'.charCodeAt(0) || next == 'G'.charCodeAt(0)) {
21079                 isGeneral = true;
21080                 precision = precision || 1;
21081                 var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
21082                 if (precision > exponent && exponent >= -4) {
21083                   next = ((next == 'g'.charCodeAt(0)) ? 'f' : 'F').charCodeAt(0);
21084                   precision -= exponent + 1;
21085                 } else {
21086                   next = ((next == 'g'.charCodeAt(0)) ? 'e' : 'E').charCodeAt(0);
21087                   precision--;
21088                 }
21089                 effectivePrecision = Math.min(precision, 20);
21090               }
21091
21092               if (next == 'e'.charCodeAt(0) || next == 'E'.charCodeAt(0)) {
21093                 argText = currArg.toExponential(effectivePrecision);
21094                 // Make sure the exponent has at least 2 digits.
21095                 if (/[eE][-+]\d$/.test(argText)) {
21096                   argText = argText.slice(0, -1) + '0' + argText.slice(-1);
21097                 }
21098               } else if (next == 'f'.charCodeAt(0) || next == 'F'.charCodeAt(0)) {
21099                 argText = currArg.toFixed(effectivePrecision);
21100               }
21101
21102               var parts = argText.split('e');
21103               if (isGeneral && !flagAlternative) {
21104                 // Discard trailing zeros and periods.
21105                 while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
21106                        (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
21107                   parts[0] = parts[0].slice(0, -1);
21108                 }
21109               } else {
21110                 // Make sure we have a period in alternative mode.
21111                 if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
21112                 // Zero pad until required precision.
21113                 while (precision > effectivePrecision++) parts[0] += '0';
21114               }
21115               argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
21116
21117               // Capitalize 'E' if needed.
21118               if (next == 'E'.charCodeAt(0)) argText = argText.toUpperCase();
21119
21120               // Add sign.
21121               if (flagAlwaysSigned && currArg >= 0) {
21122                 argText = '+' + argText;
21123               }
21124             }
21125
21126             // Add padding.
21127             while (argText.length < width) {
21128               if (flagLeftAlign) {
21129                 argText += ' ';
21130               } else {
21131                 if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
21132                   argText = argText[0] + '0' + argText.slice(1);
21133                 } else {
21134                   argText = (flagZeroPad ? '0' : ' ') + argText;
21135                 }
21136               }
21137             }
21138
21139             // Adjust case.
21140             if (next < 'a'.charCodeAt(0)) argText = argText.toUpperCase();
21141
21142             // Insert the result into the buffer.
21143             argText.split('').forEach(function(chr) {
21144               ret.push(chr.charCodeAt(0));
21145             });
21146           } else if (next == 's'.charCodeAt(0)) {
21147             // String.
21148             var arg = getNextArg('i8*') || nullString;
21149             var argLength = String_len(arg);
21150             if (precisionSet) argLength = Math.min(argLength, precision);
21151             if (!flagLeftAlign) {
21152               while (argLength < width--) {
21153                 ret.push(' '.charCodeAt(0));
21154               }
21155             }
21156             for (var i = 0; i < argLength; i++) {
21157               ret.push(HEAPU8[(arg++)]);
21158             }
21159             if (flagLeftAlign) {
21160               while (argLength < width--) {
21161                 ret.push(' '.charCodeAt(0));
21162               }
21163             }
21164           } else if (next == 'c'.charCodeAt(0)) {
21165             // Character.
21166             if (flagLeftAlign) ret.push(getNextArg('i8'));
21167             while (--width > 0) {
21168               ret.push(' '.charCodeAt(0));
21169             }
21170             if (!flagLeftAlign) ret.push(getNextArg('i8'));
21171           } else if (next == 'n'.charCodeAt(0)) {
21172             // Write the length written so far to the next parameter.
21173             var ptr = getNextArg('i32*');
21174             HEAP32[((ptr)>>2)]=ret.length
21175           } else if (next == '%'.charCodeAt(0)) {
21176             // Literal percent sign.
21177             ret.push(curr);
21178           } else {
21179             // Unknown specifiers remain untouched.
21180             for (var i = startTextIndex; i < textIndex + 2; i++) {
21181               ret.push(HEAP8[(i)]);
21182             }
21183           }
21184           textIndex += 2;
21185           // TODO: Support a/A (hex float) and m (last error) specifiers.
21186           // TODO: Support %1${specifier} for arg selection.
21187         } else {
21188           ret.push(curr);
21189           textIndex += 1;
21190         }
21191       }
21192       return ret;
21193     }function _fprintf(stream, format, varargs) {
21194       // int fprintf(FILE *restrict stream, const char *restrict format, ...);
21195       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
21196       var result = __formatString(format, varargs);
21197       var stack = Runtime.stackSave();
21198       var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
21199       Runtime.stackRestore(stack);
21200       return ret;
21201     }function _printf(format, varargs) {
21202       // int printf(const char *restrict format, ...);
21203       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
21204       var stdout = HEAP32[((_stdout)>>2)];
21205       return _fprintf(stdout, format, varargs);
21206     }
21207
21208
21209   function _memset(ptr, value, num, align) {
21210       // TODO: make these settings, and in memcpy, {{'s
21211       if (num >= 20) {
21212         // This is unaligned, but quite large, so work hard to get to aligned settings
21213         var stop = ptr + num;
21214         while (ptr % 4) { // no need to check for stop, since we have large num
21215           HEAP8[ptr++] = value;
21216         }
21217         if (value < 0) value += 256; // make it unsigned
21218         var ptr4 = ptr >> 2, stop4 = stop >> 2, value4 = value | (value << 8) | (value << 16) | (value << 24);
21219         while (ptr4 < stop4) {
21220           HEAP32[ptr4++] = value4;
21221         }
21222         ptr = ptr4 << 2;
21223         while (ptr < stop) {
21224           HEAP8[ptr++] = value;
21225         }
21226       } else {
21227         while (num--) {
21228           HEAP8[ptr++] = value;
21229         }
21230       }
21231     }var _llvm_memset_p0i8_i32=_memset;
21232 var _util_strdup; // stub for _util_strdup
21233
21234
21235   function _lseek(fildes, offset, whence) {
21236       // off_t lseek(int fildes, off_t offset, int whence);
21237       // http://pubs.opengroup.org/onlinepubs/000095399/functions/lseek.html
21238       if (FS.streams[fildes] && !FS.streams[fildes].object.isDevice) {
21239         var stream = FS.streams[fildes];
21240         var position = offset;
21241         if (whence === 1) {  // SEEK_CUR.
21242           position += stream.position;
21243         } else if (whence === 2) {  // SEEK_END.
21244           position += stream.object.contents.length;
21245         }
21246         if (position < 0) {
21247           ___setErrNo(ERRNO_CODES.EINVAL);
21248           return -1;
21249         } else {
21250           stream.ungotten = [];
21251           stream.position = position;
21252           return position;
21253         }
21254       } else {
21255         ___setErrNo(ERRNO_CODES.EBADF);
21256         return -1;
21257       }
21258     }function _fseek(stream, offset, whence) {
21259       // int fseek(FILE *stream, long offset, int whence);
21260       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fseek.html
21261       var ret = _lseek(stream, offset, whence);
21262       if (ret == -1) {
21263         return -1;
21264       } else {
21265         FS.streams[stream].eof = false;
21266         return 0;
21267       }
21268     }
21269
21270   function _strlen(ptr) {
21271       return String_len(ptr);
21272     }
21273
21274
21275   function _strncmp(px, py, n) {
21276       var i = 0;
21277       while (i < n) {
21278         var x = HEAPU8[((px)+(i))];
21279         var y = HEAPU8[((py)+(i))];
21280         if (x == y && x == 0) return 0;
21281         if (x == 0) return -1;
21282         if (y == 0) return 1;
21283         if (x == y) {
21284           i ++;
21285           continue;
21286         } else {
21287           return x > y ? 1 : -1;
21288         }
21289       }
21290       return 0;
21291     }function _strcmp(px, py) {
21292       return _strncmp(px, py, TOTAL_MEMORY);
21293     }
21294
21295   function _fflush(stream) {
21296       // int fflush(FILE *stream);
21297       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
21298       var flush = function(filedes) {
21299         // Right now we write all data directly, except for output devices.
21300         if (FS.streams[filedes] && FS.streams[filedes].object.output) {
21301           if (!FS.streams[filedes].isTerminal) { // don't flush terminals, it would cause a \n to also appear
21302             FS.streams[filedes].object.output(null);
21303           }
21304         }
21305       };
21306       try {
21307         if (stream === 0) {
21308           for (var i = 0; i < FS.streams.length; i++) if (FS.streams[i]) flush(i);
21309         } else {
21310           flush(stream);
21311         }
21312         return 0;
21313       } catch (e) {
21314         ___setErrNo(ERRNO_CODES.EIO);
21315         return -1;
21316       }
21317     }
21318
21319
21320   function _fputc(c, stream) {
21321       // int fputc(int c, FILE *stream);
21322       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
21323       var chr = unSign(c & 0xFF);
21324       HEAP8[(_fputc.ret)]=chr
21325       var ret = _write(stream, _fputc.ret, 1);
21326       if (ret == -1) {
21327         if (FS.streams[stream]) FS.streams[stream].error = true;
21328         return -1;
21329       } else {
21330         return chr;
21331       }
21332     }var _putc=_fputc;
21333
21334
21335   function __exit(status) {
21336       // void _exit(int status);
21337       // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
21338
21339
21340       exitRuntime();
21341       ABORT = true;
21342
21343       throw 'exit(' + status + ') called, at ' + new Error().stack;
21344     }function _exit(status) {
21345       __exit(status);
21346     }
21347 var _llvm_va_start; // stub for _llvm_va_start
21348
21349   var _vprintf=_printf;
21350
21351   function _llvm_va_end() {}
21352
21353
21354   function ___errno_location() {
21355       return ___setErrNo.ret;
21356     }var ___errno=___errno_location;
21357
21358
21359
21360   var ERRNO_MESSAGES={1:"Operation not permitted",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"Input/output error",6:"No such device or address",8:"Exec format error",9:"Bad file descriptor",10:"No child processes",11:"Resource temporarily unavailable",12:"Cannot allocate memory",13:"Permission denied",14:"Bad address",16:"Device or resource busy",17:"File exists",18:"Invalid cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Inappropriate ioctl for device",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read-only file system",31:"Too many links",32:"Broken pipe",33:"Numerical argument out of domain",34:"Numerical result out of range",35:"Resource deadlock avoided",36:"File name too long",37:"No locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many levels of symbolic links",42:"No message of desired type",43:"Identifier removed",60:"Device not a stream",61:"No data available",62:"Timer expired",63:"Out of streams resources",67:"Link has been severed",71:"Protocol error",72:"Multihop attempted",74:"Bad message",75:"Value too large for defined data type",84:"Invalid or incomplete multibyte or wide character",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Protocol not supported",95:"Operation not supported",97:"Address family not supported by protocol",98:"Address already in use",99:"Cannot assign requested address",100:"Network is down",101:"Network is unreachable",102:"Network dropped connection on reset",103:"Software caused connection abort",104:"Connection reset by peer",105:"No buffer space available",106:"Transport endpoint is already connected",107:"Transport endpoint is not connected",110:"Connection timed out",111:"Connection refused",113:"No route to host",114:"Operation already in progress",115:"Operation now in progress",116:"Stale NFS file handle",122:"Disk quota exceeded",125:"Operation canceled",130:"Owner died",131:"State not recoverable"};function _strerror_r(errnum, strerrbuf, buflen) {
21361       if (errnum in ERRNO_MESSAGES) {
21362         if (ERRNO_MESSAGES[errnum].length > buflen - 1) {
21363           return ___setErrNo(ERRNO_CODES.ERANGE);
21364         } else {
21365           var msg = ERRNO_MESSAGES[errnum];
21366           for (var i = 0; i < msg.length; i++) {
21367             HEAP8[((strerrbuf)+(i))]=msg.charCodeAt(i)
21368           }
21369           HEAP8[((strerrbuf)+(i))]=0
21370           return 0;
21371         }
21372       } else {
21373         return ___setErrNo(ERRNO_CODES.EINVAL);
21374       }
21375     }function _strerror(errnum) {
21376       if (!_strerror.buffer) _strerror.buffer = _malloc(256);
21377       _strerror_r(errnum, _strerror.buffer, 256);
21378       return _strerror.buffer;
21379     }
21380
21381
21382
21383   function _malloc(bytes) {
21384       /* Over-allocate to make sure it is byte-aligned by 8.
21385        * This will leak memory, but this is only the dummy
21386        * implementation (replaced by dlmalloc normally) so
21387        * not an issue.
21388        */
21389       ptr = Runtime.staticAlloc(bytes + 8);
21390       return (ptr+8) & 0xFFFFFFF8;
21391     }
21392   Module["_malloc"] = _malloc;
21393
21394   function _free(){}
21395   Module["_free"] = _free;
21396
21397   var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false,queue:[],pause:function () {
21398           Browser.mainLoop.shouldPause = true;
21399         },resume:function () {
21400           if (Browser.mainLoop.paused) {
21401             Browser.mainLoop.paused = false;
21402             Browser.mainLoop.scheduler();
21403           }
21404           Browser.mainLoop.shouldPause = false;
21405         },updateStatus:function () {
21406           if (Module['setStatus']) {
21407             var message = Module['statusMessage'] || 'Please wait...';
21408             var remaining = Browser.mainLoop.remainingBlockers;
21409             var expected = Browser.mainLoop.expectedBlockers;
21410             if (remaining) {
21411               if (remaining < expected) {
21412                 Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
21413               } else {
21414                 Module['setStatus'](message);
21415               }
21416             } else {
21417               Module['setStatus']('');
21418             }
21419           }
21420         }},pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],ensureObjects:function () {
21421         if (Browser.ensured) return;
21422         Browser.ensured = true;
21423         try {
21424           new Blob();
21425           Browser.hasBlobConstructor = true;
21426         } catch(e) {
21427           Browser.hasBlobConstructor = false;
21428           console.log("warning: no blob constructor, cannot create blobs with mimetypes");
21429         }
21430         Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
21431         Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : console.log("warning: cannot create object URLs");
21432
21433         // Support for plugins that can process preloaded files. You can add more of these to
21434         // your app by creating and appending to Module.preloadPlugins.
21435         //
21436         // Each plugin is asked if it can handle a file based on the file's name. If it can,
21437         // it is given the file's raw data. When it is done, it calls a callback with the file's
21438         // (possibly modified) data. For example, a plugin might decompress a file, or it
21439         // might create some side data structure for use later (like an Image element, etc.).
21440
21441         function getMimetype(name) {
21442           return {
21443             'jpg': 'image/jpeg',
21444             'png': 'image/png',
21445             'bmp': 'image/bmp',
21446             'ogg': 'audio/ogg',
21447             'wav': 'audio/wav',
21448             'mp3': 'audio/mpeg'
21449           }[name.substr(-3)];
21450           return ret;
21451         }
21452
21453         if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
21454
21455         var imagePlugin = {};
21456         imagePlugin['canHandle'] = function(name) {
21457           return name.substr(-4) in { '.jpg': 1, '.png': 1, '.bmp': 1 };
21458         };
21459         imagePlugin['handle'] = function(byteArray, name, onload, onerror) {
21460           var b = null;
21461           if (Browser.hasBlobConstructor) {
21462             try {
21463               b = new Blob([byteArray], { type: getMimetype(name) });
21464             } catch(e) {
21465               Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
21466             }
21467           }
21468           if (!b) {
21469             var bb = new Browser.BlobBuilder();
21470             bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
21471             b = bb.getBlob();
21472           }
21473           var url = Browser.URLObject.createObjectURL(b);
21474           assert(typeof url == 'string', 'createObjectURL must return a url as a string');
21475           var img = new Image();
21476           img.onload = function() {
21477             assert(img.complete, 'Image ' + name + ' could not be decoded');
21478             var canvas = document.createElement('canvas');
21479             canvas.width = img.width;
21480             canvas.height = img.height;
21481             var ctx = canvas.getContext('2d');
21482             ctx.drawImage(img, 0, 0);
21483             Module["preloadedImages"][name] = canvas;
21484             Browser.URLObject.revokeObjectURL(url);
21485             if (onload) onload(byteArray);
21486           };
21487           img.onerror = function(event) {
21488             console.log('Image ' + url + ' could not be decoded');
21489             if (onerror) onerror();
21490           };
21491           img.src = url;
21492         };
21493         Module['preloadPlugins'].push(imagePlugin);
21494
21495         var audioPlugin = {};
21496         audioPlugin['canHandle'] = function(name) {
21497           return name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
21498         };
21499         audioPlugin['handle'] = function(byteArray, name, onload, onerror) {
21500           var done = false;
21501           function finish(audio) {
21502             if (done) return;
21503             done = true;
21504             Module["preloadedAudios"][name] = audio;
21505             if (onload) onload(byteArray);
21506           }
21507           function fail() {
21508             if (done) return;
21509             done = true;
21510             Module["preloadedAudios"][name] = new Audio(); // empty shim
21511             if (onerror) onerror();
21512           }
21513           if (Browser.hasBlobConstructor) {
21514             try {
21515               var b = new Blob([byteArray], { type: getMimetype(name) });
21516             } catch(e) {
21517               return fail();
21518             }
21519             var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
21520             assert(typeof url == 'string', 'createObjectURL must return a url as a string');
21521             var audio = new Audio();
21522             audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
21523             audio.onerror = function(event) {
21524               if (done) return;
21525               console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
21526               function encode64(data) {
21527                 var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
21528                 var PAD = '=';
21529                 var ret = '';
21530                 var leftchar = 0;
21531                 var leftbits = 0;
21532                 for (var i = 0; i < data.length; i++) {
21533                   leftchar = (leftchar << 8) | data[i];
21534                   leftbits += 8;
21535                   while (leftbits >= 6) {
21536                     var curr = (leftchar >> (leftbits-6)) & 0x3f;
21537                     leftbits -= 6;
21538                     ret += BASE[curr];
21539                   }
21540                 }
21541                 if (leftbits == 2) {
21542                   ret += BASE[(leftchar&3) << 4];
21543                   ret += PAD + PAD;
21544                 } else if (leftbits == 4) {
21545                   ret += BASE[(leftchar&0xf) << 2];
21546                   ret += PAD;
21547                 }
21548                 return ret;
21549               }
21550               audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
21551               finish(audio); // we don't wait for confirmation this worked - but it's worth trying
21552             };
21553             audio.src = url;
21554             // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
21555             setTimeout(function() {
21556               finish(audio); // try to use it even though it is not necessarily ready to play
21557             }, 10000);
21558           } else {
21559             return fail();
21560           }
21561         };
21562         Module['preloadPlugins'].push(audioPlugin);
21563       },createContext:function (canvas, useWebGL, setInModule) {
21564         try {
21565           var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d');
21566           if (!ctx) throw ':(';
21567         } catch (e) {
21568           Module.print('Could not create canvas - ' + e);
21569           return null;
21570         }
21571         if (useWebGL) {
21572           // Set the background of the WebGL canvas to black
21573           canvas.style.backgroundColor = "black";
21574
21575           // Warn on context loss
21576           canvas.addEventListener('webglcontextlost', function(event) {
21577             alert('WebGL context lost. You will need to reload the page.');
21578           }, false);
21579         }
21580         if (setInModule) {
21581           Module.ctx = ctx;
21582           Module.useWebGL = useWebGL;
21583           Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
21584         }
21585         return ctx;
21586       },requestFullScreen:function () {
21587         var canvas = Module['canvas'];
21588         function fullScreenChange() {
21589           var isFullScreen = false;
21590           if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
21591                document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
21592                document['fullScreenElement'] || document['fullscreenElement']) === canvas) {
21593             canvas.requestPointerLock = canvas['requestPointerLock'] ||
21594                                         canvas['mozRequestPointerLock'] ||
21595                                         canvas['webkitRequestPointerLock'];
21596             canvas.requestPointerLock();
21597             isFullScreen = true;
21598           }
21599           if (Module['onFullScreen']) Module['onFullScreen'](isFullScreen);
21600         }
21601
21602         document.addEventListener('fullscreenchange', fullScreenChange, false);
21603         document.addEventListener('mozfullscreenchange', fullScreenChange, false);
21604         document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
21605
21606         function pointerLockChange() {
21607           Browser.pointerLock = document['pointerLockElement'] === canvas ||
21608                                 document['mozPointerLockElement'] === canvas ||
21609                                 document['webkitPointerLockElement'] === canvas;
21610         }
21611
21612         document.addEventListener('pointerlockchange', pointerLockChange, false);
21613         document.addEventListener('mozpointerlockchange', pointerLockChange, false);
21614         document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
21615
21616         canvas.requestFullScreen = canvas['requestFullScreen'] ||
21617                                    canvas['mozRequestFullScreen'] ||
21618                                    (canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
21619         canvas.requestFullScreen();
21620       },requestAnimationFrame:function (func) {
21621         if (!window.requestAnimationFrame) {
21622           window.requestAnimationFrame = window['requestAnimationFrame'] ||
21623                                          window['mozRequestAnimationFrame'] ||
21624                                          window['webkitRequestAnimationFrame'] ||
21625                                          window['msRequestAnimationFrame'] ||
21626                                          window['oRequestAnimationFrame'] ||
21627                                          window['setTimeout'];
21628         }
21629         window.requestAnimationFrame(func);
21630       },getMovementX:function (event) {
21631         return event['movementX'] ||
21632                event['mozMovementX'] ||
21633                event['webkitMovementX'] ||
21634                0;
21635       },getMovementY:function (event) {
21636         return event['movementY'] ||
21637                event['mozMovementY'] ||
21638                event['webkitMovementY'] ||
21639                0;
21640       },xhrLoad:function (url, onload, onerror) {
21641         var xhr = new XMLHttpRequest();
21642         xhr.open('GET', url, true);
21643         xhr.responseType = 'arraybuffer';
21644         xhr.onload = function() {
21645           if (xhr.status == 200) {
21646             onload(xhr.response);
21647           } else {
21648             onerror();
21649           }
21650         };
21651         xhr.onerror = onerror;
21652         xhr.send(null);
21653       },asyncLoad:function (url, onload, onerror) {
21654         Browser.xhrLoad(url, function(arrayBuffer) {
21655           assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
21656           onload(new Uint8Array(arrayBuffer));
21657           removeRunDependency('al ' + url);
21658         }, function(event) {
21659           if (onerror) {
21660             onerror();
21661           } else {
21662             throw 'Loading data file "' + url + '" failed.';
21663           }
21664         });
21665         addRunDependency('al ' + url);
21666       },resizeListeners:[],updateResizeListeners:function () {
21667         var canvas = Module['canvas'];
21668         Browser.resizeListeners.forEach(function(listener) {
21669           listener(canvas.width, canvas.height);
21670         });
21671       },setCanvasSize:function (width, height, noUpdates) {
21672         var canvas = Module['canvas'];
21673         canvas.width = width;
21674         canvas.height = height;
21675         if (!noUpdates) Browser.updateResizeListeners();
21676       }};
21677 __ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
21678 ___setErrNo(0);
21679 _fputc.ret = allocate([0], "i8", ALLOC_STATIC);
21680 Module["requestFullScreen"] = function() { Browser.requestFullScreen() };
21681   Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) };
21682   Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() };
21683   Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() };
21684
21685
21686 // === Auto-generated postamble setup entry stuff ===
21687
21688 Module.callMain = function callMain(args) {
21689   var argc = args.length+1;
21690   function pad() {
21691     for (var i = 0; i < 4-1; i++) {
21692       argv.push(0);
21693     }
21694   }
21695   var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ];
21696   pad();
21697   for (var i = 0; i < argc-1; i = i + 1) {
21698     argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC));
21699     pad();
21700   }
21701   argv.push(0);
21702   argv = allocate(argv, 'i32', ALLOC_STATIC);
21703
21704   return _main(argc, argv, 0);
21705 }
21706
21707
21708
21709
21710
21711
21712
21713
21714
21715
21716
21717
21718
21719
21720
21721
21722
21723
21724
21725
21726
21727
21728
21729
21730
21731
21732
21733
21734
21735
21736
21737 var _asm_instr;
21738
21739
21740
21741 var _prog_print_statement_t;
21742
21743
21744 var _stdout;
21745
21746
21747
21748
21749
21750
21751
21752
21753
21754
21755
21756
21757
21758
21759
21760
21761
21762
21763
21764
21765
21766
21767
21768
21769
21770
21771
21772
21773
21774
21775
21776
21777
21778
21779
21780
21781
21782
21783
21784
21785
21786
21787
21788
21789
21790
21791
21792
21793
21794
21795
21796
21797
21798
21799
21800
21801
21802
21803
21804
21805
21806
21807
21808
21809
21810
21811
21812
21813
21814
21815
21816
21817
21818
21819
21820
21821
21822
21823 STRING_TABLE.__str=allocate([101,120,101,99,46,99,0] /* exec.c\00 */, "i8", ALLOC_STATIC);
21824 STRING_TABLE.__str1=allocate([114,98,0] /* rb\00 */, "i8", ALLOC_STATIC);
21825 STRING_TABLE.__str2=allocate([102,97,105,108,101,100,32,116,111,32,114,101,97,100,32,104,101,97,100,101,114,32,102,114,111,109,32,39,37,115,39,0] /* failed to read heade */, "i8", ALLOC_STATIC);
21826 STRING_TABLE.__str3=allocate([104,101,97,100,101,114,32,115,97,121,115,32,116,104,105,115,32,105,115,32,97,32,118,101,114,115,105,111,110,32,37,105,32,112,114,111,103,115,44,32,119,101,32,110,101,101,100,32,118,101,114,115,105,111,110,32,54,10,0] /* header says this is  */, "i8", ALLOC_STATIC);
21827 STRING_TABLE.__str4=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,112,114,111,103,114,97,109,32,100,97,116,97,10,0] /* failed to allocate p */, "i8", ALLOC_STATIC);
21828 STRING_TABLE.__str5=allocate([102,97,105,108,101,100,32,116,111,32,115,116,111,114,101,32,112,114,111,103,114,97,109,32,110,97,109,101,0] /* failed to store prog */, "i8", ALLOC_STATIC);
21829 STRING_TABLE.__str6=allocate([115,101,101,107,32,102,97,105,108,101,100,0] /* seek failed\00 */, "i8", ALLOC_STATIC);
21830 STRING_TABLE.__str7=allocate([114,101,97,100,32,102,97,105,108,101,100,0] /* read failed\00 */, "i8", ALLOC_STATIC);
21831 STRING_TABLE.__str8=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,119,111,114,108,100,32,101,110,116,105,116,121,10,0] /* failed to allocate w */, "i8", ALLOC_STATIC);
21832 STRING_TABLE.__str9=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,119,111,114,108,100,32,100,97,116,97,10,0] /* failed to allocate w */, "i8", ALLOC_STATIC);
21833 STRING_TABLE.__str10=allocate([60,60,60,105,110,118,97,108,105,100,32,115,116,114,105,110,103,62,62,62,0] /* ___invalid string___ */, "i8", ALLOC_STATIC);
21834 STRING_TABLE.__str11=allocate([65,99,99,101,115,115,105,110,103,32,111,117,116,32,111,102,32,98,111,117,110,100,115,32,101,100,105,99,116,32,37,105,10,0] /* Accessing out of bou */, "i8", ALLOC_STATIC);
21835 STRING_TABLE.__str12=allocate([70,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,101,110,116,105,116,121,10,0] /* Failed to allocate e */, "i8", ALLOC_STATIC);
21836 STRING_TABLE.__str13=allocate([84,114,121,105,110,103,32,116,111,32,102,114,101,101,32,119,111,114,108,100,32,101,110,116,105,116,121,10,0] /* Trying to free world */, "i8", ALLOC_STATIC);
21837 STRING_TABLE.__str14=allocate([84,114,121,105,110,103,32,116,111,32,102,114,101,101,32,111,117,116,32,111,102,32,98,111,117,110,100,115,32,101,110,116,105,116,121,10,0] /* Trying to free out o */, "i8", ALLOC_STATIC);
21838 STRING_TABLE.__str15=allocate([68,111,117,98,108,101,32,102,114,101,101,32,111,110,32,101,110,116,105,116,121,10,0] /* Double free on entit */, "i8", ALLOC_STATIC);
21839 STRING_TABLE.__str16=allocate([73,108,108,101,103,97,108,32,105,110,115,116,114,117,99,116,105,111,110,32,105,110,32,37,115,10,0] /* Illegal instruction  */, "i8", ALLOC_STATIC);
21840 STRING_TABLE.__str17=allocate([112,114,111,103,115,32,96,37,115,96,32,97,116,116,101,109,112,116,101,100,32,116,111,32,114,101,97,100,32,97,110,32,111,117,116,32,111,102,32,98,111,117,110,100,115,32,101,110,116,105,116,121,0] /* progs `%s` attempted */, "i8", ALLOC_STATIC);
21841 STRING_TABLE.__str18=allocate([112,114,111,103,32,96,37,115,96,32,97,116,116,101,109,112,116,101,100,32,116,111,32,114,101,97,100,32,97,110,32,105,110,118,97,108,105,100,32,102,105,101,108,100,32,102,114,111,109,32,101,110,116,105,116,121,32,40,37,105,41,0] /* prog `%s` attempted  */, "i8", ALLOC_STATIC);
21842 STRING_TABLE.__str19=allocate([112,114,111,103,32,96,37,115,96,32,97,116,116,101,109,112,116,101,100,32,116,111,32,97,100,100,114,101,115,115,32,97,110,32,111,117,116,32,111,102,32,98,111,117,110,100,115,32,101,110,116,105,116,121,32,37,105,0] /* prog `%s` attempted  */, "i8", ALLOC_STATIC);
21843 STRING_TABLE.__str20=allocate([96,37,115,96,32,97,116,116,101,109,112,116,101,100,32,116,111,32,119,114,105,116,101,32,116,111,32,97,110,32,111,117,116,32,111,102,32,98,111,117,110,100,115,32,101,100,105,99,116,32,40,37,105,41,0] /* `%s` attempted to wr */, "i8", ALLOC_STATIC);
21844 STRING_TABLE.__str21=allocate([96,37,115,96,32,116,114,105,101,100,32,116,111,32,97,115,115,105,103,110,32,116,111,32,119,111,114,108,100,46,37,115,32,40,102,105,101,108,100,32,37,105,41,10,0] /* `%s` tried to assign */, "i8", ALLOC_STATIC);
21845 STRING_TABLE.__str22=allocate([96,37,115,96,32,104,105,116,32,116,104,101,32,114,117,110,97,119,97,121,32,108,111,111,112,32,99,111,117,110,116,101,114,32,108,105,109,105,116,32,111,102,32,37,108,105,32,106,117,109,112,115,0] /* `%s` hit the runaway */, "i8", ALLOC_STATIC);
21846 STRING_TABLE.__str23=allocate([78,85,76,76,32,102,117,110,99,116,105,111,110,32,105,110,32,96,37,115,96,0] /* NULL function in `%s */, "i8", ALLOC_STATIC);
21847 STRING_TABLE.__str24=allocate([67,65,76,76,32,111,117,116,115,105,100,101,32,116,104,101,32,112,114,111,103,114,97,109,32,105,110,32,96,37,115,96,0] /* CALL outside the pro */, "i8", ALLOC_STATIC);
21848 STRING_TABLE.__str25=allocate([78,111,32,115,117,99,104,32,98,117,105,108,116,105,110,32,35,37,105,32,105,110,32,37,115,33,32,84,114,121,32,117,112,100,97,116,105,110,103,32,121,111,117,114,32,103,109,113,99,99,32,115,111,117,114,99,101,115,0] /* No such builtin #%i  */, "i8", ALLOC_STATIC);
21849 STRING_TABLE.__str26=allocate([96,37,115,96,32,116,114,105,101,100,32,116,111,32,101,120,101,99,117,116,101,32,97,32,83,84,65,84,69,32,111,112,101,114,97,116,105,111,110,0] /* `%s` tried to execut */, "i8", ALLOC_STATIC);
21850 STRING_TABLE.__str27=allocate([60,105,108,108,101,103,97,108,32,105,110,115,116,114,117,99,116,105,111,110,32,37,100,62,10,0] /* _illegal instruction */, "i8", ALLOC_STATIC);
21851 STRING_TABLE.__str28=allocate([32,60,62,32,37,45,49,50,115,0] /*  __ %-12s\00 */, "i8", ALLOC_STATIC);
21852 _asm_instr=allocate([0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0], ["*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC);
21853 STRING_TABLE.__str29=allocate([37,100,10,0] /* %d\0A\00 */, "i8", ALLOC_STATIC);
21854 STRING_TABLE.__str30=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC);
21855 STRING_TABLE.__str31=allocate([37,105,10,0] /* %i\0A\00 */, "i8", ALLOC_STATIC);
21856 _prog_print_statement_t=allocate([2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0], ["i32",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC);
21857 STRING_TABLE.__str32=allocate([40,110,111,110,101,41,44,32,32,32,32,32,32,32,32,32,32,0] /* (none),          \00 */, "i8", ALLOC_STATIC);
21858 STRING_TABLE.__str33=allocate([40,110,111,110,101,41,0] /* (none)\00 */, "i8", ALLOC_STATIC);
21859 STRING_TABLE._trace_print_global_spaces=allocate([32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,0] /*                      */, "i8", ALLOC_STATIC);
21860 STRING_TABLE.__str34=allocate([60,110,117,108,108,62,44,0] /* _null_,\00 */, "i8", ALLOC_STATIC);
21861 STRING_TABLE.__str35=allocate([36,0] /* $\00 */, "i8", ALLOC_STATIC);
21862 STRING_TABLE.__str36=allocate([37,115,32,0] /* %s \00 */, "i8", ALLOC_STATIC);
21863 STRING_TABLE.__str37=allocate([91,64,37,117,93,32,0] /* [@%u] \00 */, "i8", ALLOC_STATIC);
21864 STRING_TABLE.__str38=allocate([40,37,105,41,44,0] /* (%i),\00 */, "i8", ALLOC_STATIC);
21865 STRING_TABLE.__str39=allocate([39,37,103,32,37,103,32,37,103,39,44,0] /* '%g %g %g',\00 */, "i8", ALLOC_STATIC);
21866 STRING_TABLE.__str40=allocate([44,0] /* ,\00 */, "i8", ALLOC_STATIC);
21867 STRING_TABLE.__str41=allocate([37,103,44,0] /* %g,\00 */, "i8", ALLOC_STATIC);
21868 STRING_TABLE.__str42=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC);
21869 STRING_TABLE.__str43=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC);
21870 STRING_TABLE.__str44=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC);
21871 STRING_TABLE.__str45=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC);
21872 STRING_TABLE.__str46=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC);
21873 STRING_TABLE.__str47=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC);
21874 STRING_TABLE.__str48=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC);
21875 STRING_TABLE.__str49=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC);
21876 STRING_TABLE.__str50=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC);
21877 STRING_TABLE.__str51=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC);
21878 STRING_TABLE.__str52=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC);
21879 STRING_TABLE.__str53=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC);
21880 STRING_TABLE.__str54=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC);
21881 STRING_TABLE.__str55=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC);
21882 STRING_TABLE.__str56=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC);
21883 STRING_TABLE.__str57=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC);
21884 STRING_TABLE.__str58=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC);
21885 STRING_TABLE.__str59=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC);
21886 STRING_TABLE.__str60=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC);
21887 STRING_TABLE.__str61=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC);
21888 STRING_TABLE.__str62=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC);
21889 STRING_TABLE.__str63=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC);
21890 STRING_TABLE.__str64=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC);
21891 STRING_TABLE.__str65=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC);
21892 STRING_TABLE.__str66=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC);
21893 STRING_TABLE.__str67=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC);
21894 STRING_TABLE.__str68=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC);
21895 STRING_TABLE.__str69=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC);
21896 STRING_TABLE.__str70=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC);
21897 STRING_TABLE.__str71=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC);
21898 STRING_TABLE.__str72=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC);
21899 STRING_TABLE.__str73=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC);
21900 STRING_TABLE.__str74=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC);
21901 STRING_TABLE.__str75=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC);
21902 STRING_TABLE.__str76=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC);
21903 STRING_TABLE.__str77=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC);
21904 STRING_TABLE.__str78=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC);
21905 STRING_TABLE.__str79=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC);
21906 STRING_TABLE.__str80=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC);
21907 STRING_TABLE.__str81=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC);
21908 STRING_TABLE.__str82=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC);
21909 STRING_TABLE.__str83=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC);
21910 STRING_TABLE.__str84=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC);
21911 STRING_TABLE.__str85=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC);
21912 STRING_TABLE.__str86=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC);
21913 STRING_TABLE.__str87=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC);
21914 STRING_TABLE.__str88=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC);
21915 STRING_TABLE.__str89=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC);
21916 STRING_TABLE.__str90=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC);
21917 STRING_TABLE.__str91=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC);
21918 STRING_TABLE.__str92=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC);
21919 STRING_TABLE.__str93=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC);
21920 STRING_TABLE.__str94=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC);
21921 STRING_TABLE.__str95=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC);
21922 STRING_TABLE.__str96=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC);
21923 STRING_TABLE.__str97=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC);
21924 STRING_TABLE.__str98=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC);
21925 STRING_TABLE.__str99=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC);
21926 STRING_TABLE.__str100=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC);
21927 STRING_TABLE.__str101=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC);
21928 STRING_TABLE.__str102=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC);
21929 STRING_TABLE.__str103=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC);
21930 STRING_TABLE.__str104=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC);
21931 STRING_TABLE.__str105=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC);
21932 STRING_TABLE.__str106=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC);
21933 STRING_TABLE.__str107=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC);
21934 STRING_TABLE.__str108=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC);
21935 STRING_TABLE.__str109=allocate([111,117,116,32,111,102,32,109,101,109,111,114,121,10,0] /* out of memory\0A\00 */, "i8", ALLOC_STATIC);
21936 STRING_TABLE.__str110=allocate([58,32,37,115,10,0] /* : %s\0A\00 */, "i8", ALLOC_STATIC);
21937 HEAP32[((_asm_instr)>>2)]=((STRING_TABLE.__str42)|0);
21938 HEAP32[(((_asm_instr)+(12))>>2)]=((STRING_TABLE.__str43)|0);
21939 HEAP32[(((_asm_instr)+(24))>>2)]=((STRING_TABLE.__str44)|0);
21940 HEAP32[(((_asm_instr)+(36))>>2)]=((STRING_TABLE.__str45)|0);
21941 HEAP32[(((_asm_instr)+(48))>>2)]=((STRING_TABLE.__str46)|0);
21942 HEAP32[(((_asm_instr)+(60))>>2)]=((STRING_TABLE.__str47)|0);
21943 HEAP32[(((_asm_instr)+(72))>>2)]=((STRING_TABLE.__str48)|0);
21944 HEAP32[(((_asm_instr)+(84))>>2)]=((STRING_TABLE.__str49)|0);
21945 HEAP32[(((_asm_instr)+(96))>>2)]=((STRING_TABLE.__str50)|0);
21946 HEAP32[(((_asm_instr)+(108))>>2)]=((STRING_TABLE.__str51)|0);
21947 HEAP32[(((_asm_instr)+(120))>>2)]=((STRING_TABLE.__str52)|0);
21948 HEAP32[(((_asm_instr)+(132))>>2)]=((STRING_TABLE.__str53)|0);
21949 HEAP32[(((_asm_instr)+(144))>>2)]=((STRING_TABLE.__str54)|0);
21950 HEAP32[(((_asm_instr)+(156))>>2)]=((STRING_TABLE.__str55)|0);
21951 HEAP32[(((_asm_instr)+(168))>>2)]=((STRING_TABLE.__str56)|0);
21952 HEAP32[(((_asm_instr)+(180))>>2)]=((STRING_TABLE.__str57)|0);
21953 HEAP32[(((_asm_instr)+(192))>>2)]=((STRING_TABLE.__str58)|0);
21954 HEAP32[(((_asm_instr)+(204))>>2)]=((STRING_TABLE.__str59)|0);
21955 HEAP32[(((_asm_instr)+(216))>>2)]=((STRING_TABLE.__str60)|0);
21956 HEAP32[(((_asm_instr)+(228))>>2)]=((STRING_TABLE.__str61)|0);
21957 HEAP32[(((_asm_instr)+(240))>>2)]=((STRING_TABLE.__str62)|0);
21958 HEAP32[(((_asm_instr)+(252))>>2)]=((STRING_TABLE.__str63)|0);
21959 HEAP32[(((_asm_instr)+(264))>>2)]=((STRING_TABLE.__str64)|0);
21960 HEAP32[(((_asm_instr)+(276))>>2)]=((STRING_TABLE.__str65)|0);
21961 HEAP32[(((_asm_instr)+(288))>>2)]=((STRING_TABLE.__str66)|0);
21962 HEAP32[(((_asm_instr)+(300))>>2)]=((STRING_TABLE.__str67)|0);
21963 HEAP32[(((_asm_instr)+(312))>>2)]=((STRING_TABLE.__str68)|0);
21964 HEAP32[(((_asm_instr)+(324))>>2)]=((STRING_TABLE.__str69)|0);
21965 HEAP32[(((_asm_instr)+(336))>>2)]=((STRING_TABLE.__str70)|0);
21966 HEAP32[(((_asm_instr)+(348))>>2)]=((STRING_TABLE.__str71)|0);
21967 HEAP32[(((_asm_instr)+(360))>>2)]=((STRING_TABLE.__str72)|0);
21968 HEAP32[(((_asm_instr)+(372))>>2)]=((STRING_TABLE.__str73)|0);
21969 HEAP32[(((_asm_instr)+(384))>>2)]=((STRING_TABLE.__str74)|0);
21970 HEAP32[(((_asm_instr)+(396))>>2)]=((STRING_TABLE.__str75)|0);
21971 HEAP32[(((_asm_instr)+(408))>>2)]=((STRING_TABLE.__str76)|0);
21972 HEAP32[(((_asm_instr)+(420))>>2)]=((STRING_TABLE.__str77)|0);
21973 HEAP32[(((_asm_instr)+(432))>>2)]=((STRING_TABLE.__str78)|0);
21974 HEAP32[(((_asm_instr)+(444))>>2)]=((STRING_TABLE.__str79)|0);
21975 HEAP32[(((_asm_instr)+(456))>>2)]=((STRING_TABLE.__str80)|0);
21976 HEAP32[(((_asm_instr)+(468))>>2)]=((STRING_TABLE.__str81)|0);
21977 HEAP32[(((_asm_instr)+(480))>>2)]=((STRING_TABLE.__str82)|0);
21978 HEAP32[(((_asm_instr)+(492))>>2)]=((STRING_TABLE.__str83)|0);
21979 HEAP32[(((_asm_instr)+(504))>>2)]=((STRING_TABLE.__str84)|0);
21980 HEAP32[(((_asm_instr)+(516))>>2)]=((STRING_TABLE.__str85)|0);
21981 HEAP32[(((_asm_instr)+(528))>>2)]=((STRING_TABLE.__str86)|0);
21982 HEAP32[(((_asm_instr)+(540))>>2)]=((STRING_TABLE.__str87)|0);
21983 HEAP32[(((_asm_instr)+(552))>>2)]=((STRING_TABLE.__str88)|0);
21984 HEAP32[(((_asm_instr)+(564))>>2)]=((STRING_TABLE.__str89)|0);
21985 HEAP32[(((_asm_instr)+(576))>>2)]=((STRING_TABLE.__str90)|0);
21986 HEAP32[(((_asm_instr)+(588))>>2)]=((STRING_TABLE.__str91)|0);
21987 HEAP32[(((_asm_instr)+(600))>>2)]=((STRING_TABLE.__str92)|0);
21988 HEAP32[(((_asm_instr)+(612))>>2)]=((STRING_TABLE.__str93)|0);
21989 HEAP32[(((_asm_instr)+(624))>>2)]=((STRING_TABLE.__str94)|0);
21990 HEAP32[(((_asm_instr)+(636))>>2)]=((STRING_TABLE.__str95)|0);
21991 HEAP32[(((_asm_instr)+(648))>>2)]=((STRING_TABLE.__str96)|0);
21992 HEAP32[(((_asm_instr)+(660))>>2)]=((STRING_TABLE.__str97)|0);
21993 HEAP32[(((_asm_instr)+(672))>>2)]=((STRING_TABLE.__str98)|0);
21994 HEAP32[(((_asm_instr)+(684))>>2)]=((STRING_TABLE.__str99)|0);
21995 HEAP32[(((_asm_instr)+(696))>>2)]=((STRING_TABLE.__str100)|0);
21996 HEAP32[(((_asm_instr)+(708))>>2)]=((STRING_TABLE.__str101)|0);
21997 HEAP32[(((_asm_instr)+(720))>>2)]=((STRING_TABLE.__str102)|0);
21998 HEAP32[(((_asm_instr)+(732))>>2)]=((STRING_TABLE.__str103)|0);
21999 HEAP32[(((_asm_instr)+(744))>>2)]=((STRING_TABLE.__str104)|0);
22000 HEAP32[(((_asm_instr)+(756))>>2)]=((STRING_TABLE.__str105)|0);
22001 HEAP32[(((_asm_instr)+(768))>>2)]=((STRING_TABLE.__str106)|0);
22002 HEAP32[(((_asm_instr)+(780))>>2)]=((STRING_TABLE.__str107)|0);
22003 HEAP32[(((_asm_instr)+(792))>>2)]=((STRING_TABLE.__str108)|0);
22004 FUNCTION_TABLE = [0,0]; Module["FUNCTION_TABLE"] = FUNCTION_TABLE;
22005
22006
22007 function run(args) {
22008   args = args || Module['arguments'];
22009
22010   if (runDependencies > 0) {
22011     Module.printErr('run() called, but dependencies remain, so not running');
22012     return 0;
22013   }
22014
22015   if (Module['preRun']) {
22016     if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
22017     var toRun = Module['preRun'];
22018     Module['preRun'] = [];
22019     for (var i = toRun.length-1; i >= 0; i--) {
22020       toRun[i]();
22021     }
22022     if (runDependencies > 0) {
22023       // a preRun added a dependency, run will be called later
22024       return 0;
22025     }
22026   }
22027
22028   function doRun() {
22029     var ret = 0;
22030     calledRun = true;
22031     if (Module['_main']) {
22032       preMain();
22033       ret = Module.callMain(args);
22034       if (!Module['noExitRuntime']) {
22035         exitRuntime();
22036       }
22037     }
22038     if (Module['postRun']) {
22039       if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
22040       while (Module['postRun'].length > 0) {
22041         Module['postRun'].pop()();
22042       }
22043     }
22044     return ret;
22045   }
22046
22047   if (Module['setStatus']) {
22048     Module['setStatus']('Running...');
22049     setTimeout(function() {
22050       setTimeout(function() {
22051         Module['setStatus']('');
22052       }, 1);
22053       doRun();
22054     }, 1);
22055     return 0;
22056   } else {
22057     return doRun();
22058   }
22059 }
22060 Module['run'] = run;
22061
22062 // {{PRE_RUN_ADDITIONS}}
22063
22064 if (Module['preInit']) {
22065   if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
22066   while (Module['preInit'].length > 0) {
22067     Module['preInit'].pop()();
22068   }
22069 }
22070
22071 initRuntime();
22072
22073 var shouldRunNow = true;
22074 if (Module['noInitialRun']) {
22075   shouldRunNow = false;
22076 }
22077
22078 if (shouldRunNow) {
22079   var ret = run();
22080 }
22081
22082 // {{POST_RUN_ADDITIONS}}
22083
22084
22085
22086
22087
22088
22089   // {{MODULE_ADDITIONS}}
22090
22091
22092 // EMSCRIPTEN_GENERATED_FUNCTIONS: ["_qc_program_entitydata_add","_qc_program_stack_remove","_qc_program_strings_add","_qc_program_fields_remove","_qc_program_profile_remove","_qc_program_globals_add","_qc_program_functions_add","_prog_getstring","_loaderror","_qc_program_localstack_remove","_qc_program_localstack_resize","_trace_print_global","_qc_program_localstack_add","_qc_program_globals_remove","_qc_program_strings_resize","_prog_free_entity","_qcvmerror","_qc_program_entitydata_remove","_qc_program_functions_remove","_prog_tempstring","_qc_program_fields_add","_qc_program_builtins_add","_qc_program_builtins_remove","_prog_load","_prog_spawn_entity","_prog_getdef","_prog_entfield","_prog_delete","_qc_program_defs_add","_qc_program_strings_remove","_prog_exec","_qc_program_entitypool_remove","_qc_program_code_remove","_qc_program_defs_remove","_qc_program_entitypool_add","_qc_program_stack_add","_prog_print_statement","_qc_program_strings_append","_prog_getedict","_print_escaped_string","_qc_program_localstack_append","_qc_program_profile_resize","_prog_enterfunction","_qc_program_profile_add","_prog_leavefunction","_qc_program_code_add"]
22093