javascripts/vm.js

   1 var Module = {
   2     preRun: [],
   3     noInitialRun: true,
   4     postRun: [],
   5     print: (function() {
   6         var element = document.getElementById('output');
   7         element.value = ''; // clear browser cache
   8         return function(text) {
   9             // These replacements are necessary if you render to raw HTML
  10             //text = text.replace(/&/g, "&amp;");
  11             //text = text.replace(/</g, "&lt;");
  12             //text = text.replace(/>/g, "&gt;");
  13             //text = text.replace('\n', '<br>', 'g');
  14             element.value += text + "\n";
  15             element.scrollTop = 99999; // focus on bottom
  16         };
  17     })(),
  18     printErr: function(text) {
  19         if (0) { // XXX disabled for safety typeof dump == 'function') {
  20             dump(text + '\n'); // fast, straight to the real console
  21         } else {
  22             console.log(text);
  23         }
  24     }
  25 };
  26
  27 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
  28 // Note: Some Emscripten settings may limit the speed of the generated code.
  29 // TODO: " u s e   s t r i c t ";
  30
  31 try {
  32   this['Module'] = Module;
  33 } catch(e) {
  34   this['Module'] = Module = {};
  35 }
  36
  37 // The environment setup code below is customized to use Module.
  38 // *** Environment setup code ***
  39 var ENVIRONMENT_IS_NODE = typeof process === 'object';
  40 var ENVIRONMENT_IS_WEB = typeof window === 'object';
  41 var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
  42 var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
  43
  44 if (ENVIRONMENT_IS_NODE) {
  45   // Expose functionality in the same simple way that the shells work
  46   // Note that we pollute the global namespace here, otherwise we break in node
  47   Module['print'] = function(x) {
  48     process['stdout'].write(x + '\n');
  49   };
  50   Module['printErr'] = function(x) {
  51     process['stderr'].write(x + '\n');
  52   };
  53
  54   var nodeFS = require('fs');
  55   var nodePath = require('path');
  56
  57   Module['read'] = function(filename) {
  58     filename = nodePath['normalize'](filename);
  59     var ret = nodeFS['readFileSync'](filename).toString();
  60     // The path is absolute if the normalized version is the same as the resolved.
  61     if (!ret && filename != nodePath['resolve'](filename)) {
  62       filename = path.join(__dirname, '..', 'src', filename);
  63       ret = nodeFS['readFileSync'](filename).toString();
  64     }
  65     return ret;
  66   };
  67
  68   Module['load'] = function(f) {
  69     globalEval(read(f));
  70   };
  71
  72   if (!Module['arguments']) {
  73     Module['arguments'] = process['argv'].slice(2);
  74   }
  75 }
  76
  77 if (ENVIRONMENT_IS_SHELL) {
  78   Module['print'] = print;
  79   if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
  80
  81   // Polyfill over SpiderMonkey/V8 differences
  82   if (typeof read != 'undefined') {
  83     Module['read'] = read;
  84   } else {
  85     Module['read'] = function(f) { snarf(f) };
  86   }
  87
  88   if (!Module['arguments']) {
  89     if (typeof scriptArgs != 'undefined') {
  90       Module['arguments'] = scriptArgs;
  91     } else if (typeof arguments != 'undefined') {
  92       Module['arguments'] = arguments;
  93     }
  94   }
  95 }
  96
  97 if (ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER) {
  98   if (!Module['print']) {
  99     Module['print'] = function(x) {
 100       console.log(x);
 101     };
 102   }
 103
 104   if (!Module['printErr']) {
 105     Module['printErr'] = function(x) {
 106       console.log(x);
 107     };
 108   }
 109 }
 110
 111 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
 112   Module['read'] = function(url) {
 113     var xhr = new XMLHttpRequest();
 114     xhr.open('GET', url, false);
 115     xhr.send(null);
 116     return xhr.responseText;
 117   };
 118
 119   if (!Module['arguments']) {
 120     if (typeof arguments != 'undefined') {
 121       Module['arguments'] = arguments;
 122     }
 123   }
 124 }
 125
 126 if (ENVIRONMENT_IS_WORKER) {
 127   // We can do very little here...
 128   var TRY_USE_DUMP = false;
 129   if (!Module['print']) {
 130     Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
 131       dump(x);
 132     }) : (function(x) {
 133       // self.postMessage(x); // enable this if you want stdout to be sent as messages
 134     }));
 135   }
 136
 137   Module['load'] = importScripts;
 138 }
 139
 140 if (!ENVIRONMENT_IS_WORKER && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL) {
 141   // Unreachable because SHELL is dependant on the others
 142   throw 'Unknown runtime environment. Where are we?';
 143 }
 144
 145 function globalEval(x) {
 146   eval.call(null, x);
 147 }
 148 if (!Module['load'] == 'undefined' && Module['read']) {
 149   Module['load'] = function(f) {
 150     globalEval(Module['read'](f));
 151   };
 152 }
 153 if (!Module['print']) {
 154   Module['print'] = function(){};
 155 }
 156 if (!Module['printErr']) {
 157   Module['printErr'] = Module['print'];
 158 }
 159 if (!Module['arguments']) {
 160   Module['arguments'] = [];
 161 }
 162 // *** Environment setup code ***
 163
 164 // Closure helpers
 165 Module.print = Module['print'];
 166 Module.printErr = Module['printErr'];
 167
 168 // Callbacks
 169 if (!Module['preRun']) Module['preRun'] = [];
 170 if (!Module['postRun']) Module['postRun'] = [];
 171
 172
 173 // === Auto-generated preamble library stuff ===
 174
 175 //========================================
 176 // Runtime code shared with compiler
 177 //========================================
 178
 179 var Runtime = {
 180   stackSave: function () {
 181     return STACKTOP;
 182   },
 183   stackRestore: function (stackTop) {
 184     STACKTOP = stackTop;
 185   },
 186   forceAlign: function (target, quantum) {
 187     quantum = quantum || 4;
 188     if (quantum == 1) return target;
 189     if (isNumber(target) && isNumber(quantum)) {
 190       return Math.ceil(target/quantum)*quantum;
 191     } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
 192       var logg = log2(quantum);
 193       return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')';
 194     }
 195     return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
 196   },
 197   isNumberType: function (type) {
 198     return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
 199   },
 200   isPointerType: function isPointerType(type) {
 201   return type[type.length-1] == '*';
 202 },
 203   isStructType: function isStructType(type) {
 204   if (isPointerType(type)) return false;
 205   if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs
 206   if (/<?{ ?[^}]* ?}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
 207   // See comment in isStructPointerType()
 208   return type[0] == '%';
 209 },
 210   INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
 211   FLOAT_TYPES: {"float":0,"double":0},
 212   bitshift64: function (low, high, op, bits) {
 213     var ander = Math.pow(2, bits)-1;
 214     if (bits < 32) {
 215       switch (op) {
 216         case 'shl':
 217           return [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))];
 218         case 'ashr':
 219           return [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0];
 220         case 'lshr':
 221           return [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits];
 222       }
 223     } else if (bits == 32) {
 224       switch (op) {
 225         case 'shl':
 226           return [0, low];
 227         case 'ashr':
 228           return [high, (high|0) < 0 ? ander : 0];
 229         case 'lshr':
 230           return [high, 0];
 231       }
 232     } else { // bits > 32
 233       switch (op) {
 234         case 'shl':
 235           return [0, low << (bits - 32)];
 236         case 'ashr':
 237           return [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0];
 238         case 'lshr':
 239           return [high >>>  (bits - 32) , 0];
 240       }
 241     }
 242     abort('unknown bitshift64 op: ' + [value, op, bits]);
 243   },
 244   or64: function (x, y) {
 245     var l = (x | 0) | (y | 0);
 246     var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
 247     return l + h;
 248   },
 249   and64: function (x, y) {
 250     var l = (x | 0) & (y | 0);
 251     var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
 252     return l + h;
 253   },
 254   xor64: function (x, y) {
 255     var l = (x | 0) ^ (y | 0);
 256     var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
 257     return l + h;
 258   },
 259   getNativeTypeSize: function (type, quantumSize) {
 260     if (Runtime.QUANTUM_SIZE == 1) return 1;
 261     var size = {
 262       '%i1': 1,
 263       '%i8': 1,
 264       '%i16': 2,
 265       '%i32': 4,
 266       '%i64': 8,
 267       "%float": 4,
 268       "%double": 8
 269     }['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc
 270     if (!size) {
 271       if (type.charAt(type.length-1) == '*') {
 272         size = Runtime.QUANTUM_SIZE; // A pointer
 273       } else if (type[0] == 'i') {
 274         var bits = parseInt(type.substr(1));
 275         assert(bits % 8 == 0);
 276         size = bits/8;
 277       }
 278     }
 279     return size;
 280   },
 281   getNativeFieldSize: function (type) {
 282     return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
 283   },
 284   dedup: function dedup(items, ident) {
 285   var seen = {};
 286   if (ident) {
 287     return items.filter(function(item) {
 288       if (seen[item[ident]]) return false;
 289       seen[item[ident]] = true;
 290       return true;
 291     });
 292   } else {
 293     return items.filter(function(item) {
 294       if (seen[item]) return false;
 295       seen[item] = true;
 296       return true;
 297     });
 298   }
 299 },
 300   set: function set() {
 301   var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
 302   var ret = {};
 303   for (var i = 0; i < args.length; i++) {
 304     ret[args[i]] = 0;
 305   }
 306   return ret;
 307 },
 308   calculateStructAlignment: function calculateStructAlignment(type) {
 309     type.flatSize = 0;
 310     type.alignSize = 0;
 311     var diffs = [];
 312     var prev = -1;
 313     type.flatIndexes = type.fields.map(function(field) {
 314       var size, alignSize;
 315       if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
 316         size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
 317         alignSize = size;
 318       } else if (Runtime.isStructType(field)) {
 319         size = Types.types[field].flatSize;
 320         alignSize = Types.types[field].alignSize;
 321       } else {
 322         throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]);
 323       }
 324       alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE);
 325       type.alignSize = Math.max(type.alignSize, alignSize);
 326       var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
 327       type.flatSize = curr + size;
 328       if (prev >= 0) {
 329         diffs.push(curr-prev);
 330       }
 331       prev = curr;
 332       return curr;
 333     });
 334     type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
 335     if (diffs.length == 0) {
 336       type.flatFactor = type.flatSize;
 337     } else if (Runtime.dedup(diffs).length == 1) {
 338       type.flatFactor = diffs[0];
 339     }
 340     type.needsFlattening = (type.flatFactor != 1);
 341     return type.flatIndexes;
 342   },
 343   generateStructInfo: function (struct, typeName, offset) {
 344     var type, alignment;
 345     if (typeName) {
 346       offset = offset || 0;
 347       type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
 348       if (!type) return null;
 349       if (type.fields.length != struct.length) {
 350         printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
 351         return null;
 352       }
 353       alignment = type.flatIndexes;
 354     } else {
 355       var type = { fields: struct.map(function(item) { return item[0] }) };
 356       alignment = Runtime.calculateStructAlignment(type);
 357     }
 358     var ret = {
 359       __size__: type.flatSize
 360     };
 361     if (typeName) {
 362       struct.forEach(function(item, i) {
 363         if (typeof item === 'string') {
 364           ret[item] = alignment[i] + offset;
 365         } else {
 366           // embedded struct
 367           var key;
 368           for (var k in item) key = k;
 369           ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
 370         }
 371       });
 372     } else {
 373       struct.forEach(function(item, i) {
 374         ret[item[1]] = alignment[i];
 375       });
 376     }
 377     return ret;
 378   },
 379   addFunction: function (func) {
 380     var ret = FUNCTION_TABLE.length;
 381     FUNCTION_TABLE.push(func);
 382     FUNCTION_TABLE.push(0);
 383     return ret;
 384   },
 385   warnOnce: function (text) {
 386     if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
 387     if (!Runtime.warnOnce.shown[text]) {
 388       Runtime.warnOnce.shown[text] = 1;
 389       Module.printErr(text);
 390     }
 391   },
 392   funcWrappers: {},
 393   getFuncWrapper: function (func) {
 394     if (!Runtime.funcWrappers[func]) {
 395       Runtime.funcWrappers[func] = function() {
 396         FUNCTION_TABLE[func].apply(null, arguments);
 397       };
 398     }
 399     return Runtime.funcWrappers[func];
 400   },
 401   UTF8Processor: function () {
 402     var buffer = [];
 403     var needed = 0;
 404     this.processCChar = function (code) {
 405       code = code & 0xff;
 406       if (needed) {
 407         buffer.push(code);
 408         needed--;
 409       }
 410       if (buffer.length == 0) {
 411         if (code < 128) return String.fromCharCode(code);
 412         buffer.push(code);
 413         if (code > 191 && code < 224) {
 414           needed = 1;
 415         } else {
 416           needed = 2;
 417         }
 418         return '';
 419       }
 420       if (needed > 0) return '';
 421       var c1 = buffer[0];
 422       var c2 = buffer[1];
 423       var c3 = buffer[2];
 424       var ret;
 425       if (c1 > 191 && c1 < 224) {
 426         ret = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
 427       } else {
 428         ret = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
 429       }
 430       buffer.length = 0;
 431       return ret;
 432     }
 433     this.processJSString = function(string) {
 434       string = unescape(encodeURIComponent(string));
 435       var ret = [];
 436       for (var i = 0; i < string.length; i++) {
 437         ret.push(string.charCodeAt(i));
 438       }
 439       return ret;
 440     }
 441   },
 442   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; },
 443   staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP += size;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
 444   alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; },
 445   makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; },
 446   QUANTUM_SIZE: 4,
 447   __dummy__: 0
 448 }
 449
 450
 451
 452 var CorrectionsMonitor = {
 453   MAX_ALLOWED: 0, // XXX
 454   corrections: 0,
 455   sigs: {},
 456
 457   note: function(type, succeed, sig) {
 458     if (!succeed) {
 459       this.corrections++;
 460       if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!');
 461     }
 462   },
 463
 464   print: function() {
 465   }
 466 };
 467
 468
 469
 470
 471
 472 //========================================
 473 // Runtime essentials
 474 //========================================
 475
 476 var __THREW__ = false; // Used in checking for thrown exceptions.
 477
 478 var ABORT = false;
 479
 480 var undef = 0;
 481 // tempInt is used for 32-bit signed values or smaller. tempBigInt is used
 482 // for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
 483 var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD;
 484 var tempI64, tempI64b;
 485
 486 function abort(text) {
 487   Module.print(text + ':\n' + (new Error).stack);
 488   ABORT = true;
 489   throw "Assertion: " + text;
 490 }
 491
 492 function assert(condition, text) {
 493   if (!condition) {
 494     abort('Assertion failed: ' + text);
 495   }
 496 }
 497
 498 var globalScope = this;
 499
 500 // C calling interface. A convenient way to call C functions (in C files, or
 501 // defined with extern "C").
 502 //
 503 // Note: LLVM optimizations can inline and remove functions, after which you will not be
 504 //       able to call them. Adding
 505 //
 506 //         __attribute__((used))
 507 //
 508 //       to the function definition will prevent that.
 509 //
 510 // Note: Closure optimizations will minify function names, making
 511 //       functions no longer callable. If you run closure (on by default
 512 //       in -O2 and above), you should export the functions you will call
 513 //       by calling emcc with something like
 514 //
 515 //         -s EXPORTED_FUNCTIONS='["_func1","_func2"]'
 516 //
 517 // @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
 518 // @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
 519 //                   'array' for JavaScript arrays and typed arrays).
 520 // @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,
 521 //                   except that 'array' is not possible (there is no way for us to know the length of the array)
 522 // @param args       An array of the arguments to the function, as native JS values (as in returnType)
 523 //                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
 524 // @return           The return value, as a native JS value (as in returnType)
 525 function ccall(ident, returnType, argTypes, args) {
 526   var stack = 0;
 527   function toC(value, type) {
 528     if (type == 'string') {
 529       if (value === null || value === undefined || value === 0) return 0; // null string
 530       if (!stack) stack = Runtime.stackSave();
 531       var ret = Runtime.stackAlloc(value.length+1);
 532       writeStringToMemory(value, ret);
 533       return ret;
 534     } else if (type == 'array') {
 535       if (!stack) stack = Runtime.stackSave();
 536       var ret = Runtime.stackAlloc(value.length);
 537       writeArrayToMemory(value, ret);
 538       return ret;
 539     }
 540     return value;
 541   }
 542   function fromC(value, type) {
 543     if (type == 'string') {
 544       return Pointer_stringify(value);
 545     }
 546     assert(type != 'array');
 547     return value;
 548   }
 549   try {
 550     var func = eval('_' + ident);
 551   } catch(e) {
 552     try {
 553       func = globalScope['Module']['_' + ident]; // closure exported function
 554     } catch(e) {}
 555   }
 556   assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
 557   var i = 0;
 558   var cArgs = args ? args.map(function(arg) {
 559     return toC(arg, argTypes[i++]);
 560   }) : [];
 561   var ret = fromC(func.apply(null, cArgs), returnType);
 562   if (stack) Runtime.stackRestore(stack);
 563   return ret;
 564 }
 565 Module["ccall"] = ccall;
 566
 567 // Returns a native JS wrapper for a C function. This is similar to ccall, but
 568 // returns a function you can call repeatedly in a normal way. For example:
 569 //
 570 //   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
 571 //   alert(my_function(5, 22));
 572 //   alert(my_function(99, 12));
 573 //
 574 function cwrap(ident, returnType, argTypes) {
 575   // TODO: optimize this, eval the whole function once instead of going through ccall each time
 576   return function() {
 577     return ccall(ident, returnType, argTypes, Array.prototype.slice.call(arguments));
 578   }
 579 }
 580 Module["cwrap"] = cwrap;
 581
 582 // Sets a value in memory in a dynamic way at run-time. Uses the
 583 // type data. This is the same as makeSetValue, except that
 584 // makeSetValue is done at compile-time and generates the needed
 585 // code then, whereas this function picks the right code at
 586 // run-time.
 587 // Note that setValue and getValue only do *aligned* writes and reads!
 588 // Note that ccall uses JS types as for defining types, while setValue and
 589 // getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
 590 function setValue(ptr, value, type, noSafe) {
 591   type = type || 'i8';
 592   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
 593     switch(type) {
 594       case 'i1': HEAP8[(ptr)]=value; break;
 595       case 'i8': HEAP8[(ptr)]=value; break;
 596       case 'i16': HEAP16[((ptr)>>1)]=value; break;
 597       case 'i32': HEAP32[((ptr)>>2)]=value; break;
 598       case 'i64': (tempI64 = [value>>>0,Math.min(Math.floor((value)/4294967296), 4294967295)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
 599       case 'float': HEAPF32[((ptr)>>2)]=value; break;
 600       case 'double': (tempDoubleF64[0]=value,HEAP32[((ptr)>>2)]=tempDoubleI32[0],HEAP32[(((ptr)+(4))>>2)]=tempDoubleI32[1]); break;
 601       default: abort('invalid type for setValue: ' + type);
 602     }
 603 }
 604 Module['setValue'] = setValue;
 605
 606 // Parallel to setValue.
 607 function getValue(ptr, type, noSafe) {
 608   type = type || 'i8';
 609   if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
 610     switch(type) {
 611       case 'i1': return HEAP8[(ptr)];
 612       case 'i8': return HEAP8[(ptr)];
 613       case 'i16': return HEAP16[((ptr)>>1)];
 614       case 'i32': return HEAP32[((ptr)>>2)];
 615       case 'i64': return HEAP32[((ptr)>>2)];
 616       case 'float': return HEAPF32[((ptr)>>2)];
 617       case 'double': return (tempDoubleI32[0]=HEAP32[((ptr)>>2)],tempDoubleI32[1]=HEAP32[(((ptr)+(4))>>2)],tempDoubleF64[0]);
 618       default: abort('invalid type for setValue: ' + type);
 619     }
 620   return null;
 621 }
 622 Module['getValue'] = getValue;
 623
 624 var ALLOC_NORMAL = 0; // Tries to use _malloc()
 625 var ALLOC_STACK = 1; // Lives for the duration of the current function call
 626 var ALLOC_STATIC = 2; // Cannot be freed
 627 Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
 628 Module['ALLOC_STACK'] = ALLOC_STACK;
 629 Module['ALLOC_STATIC'] = ALLOC_STATIC;
 630
 631 // allocate(): This is for internal use. You can use it yourself as well, but the interface
 632 //             is a little tricky (see docs right below). The reason is that it is optimized
 633 //             for multiple syntaxes to save space in generated code. So you should
 634 //             normally not use allocate(), and instead allocate memory using _malloc(),
 635 //             initialize it with setValue(), and so forth.
 636 // @slab: An array of data, or a number. If a number, then the size of the block to allocate,
 637 //        in *bytes* (note that this is sometimes confusing: the next parameter does not
 638 //        affect this!)
 639 // @types: Either an array of types, one for each byte (or 0 if no type at that position),
 640 //         or a single type which is used for the entire block. This only matters if there
 641 //         is initial data - if @slab is a number, then this does not matter at all and is
 642 //         ignored.
 643 // @allocator: How to allocate memory, see ALLOC_*
 644 function allocate(slab, types, allocator) {
 645   var zeroinit, size;
 646   if (typeof slab === 'number') {
 647     zeroinit = true;
 648     size = slab;
 649   } else {
 650     zeroinit = false;
 651     size = slab.length;
 652   }
 653
 654   var singleType = typeof types === 'string' ? types : null;
 655
 656   var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
 657
 658   if (zeroinit) {
 659       _memset(ret, 0, size);
 660       return ret;
 661   }
 662
 663   var i = 0, type;
 664   while (i < size) {
 665     var curr = slab[i];
 666
 667     if (typeof curr === 'function') {
 668       curr = Runtime.getFunctionIndex(curr);
 669     }
 670
 671     type = singleType || types[i];
 672     if (type === 0) {
 673       i++;
 674       continue;
 675     }
 676     assert(type, 'Must know what type to store in allocate!');
 677
 678     if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
 679
 680     setValue(ret+i, curr, type);
 681     i += Runtime.getNativeTypeSize(type);
 682   }
 683
 684   return ret;
 685 }
 686 Module['allocate'] = allocate;
 687
 688 function Pointer_stringify(ptr, /* optional */ length) {
 689   var utf8 = new Runtime.UTF8Processor();
 690   var nullTerminated = typeof(length) == "undefined";
 691   var ret = "";
 692   var i = 0;
 693   var t;
 694   while (1) {
 695     t = HEAPU8[((ptr)+(i))];
 696     if (nullTerminated && t == 0) break;
 697     ret += utf8.processCChar(t);
 698     i += 1;
 699     if (!nullTerminated && i == length) break;
 700   }
 701   return ret;
 702 }
 703 Module['Pointer_stringify'] = Pointer_stringify;
 704
 705 function Array_stringify(array) {
 706   var ret = "";
 707   for (var i = 0; i < array.length; i++) {
 708     ret += String.fromCharCode(array[i]);
 709   }
 710   return ret;
 711 }
 712 Module['Array_stringify'] = Array_stringify;
 713
 714 // Memory management
 715
 716 var FUNCTION_TABLE; // XXX: In theory the indexes here can be equal to pointers to stacked or malloced memory. Such comparisons should
 717                     //      be false, but can turn out true. We should probably set the top bit to prevent such issues.
 718
 719 var PAGE_SIZE = 4096;
 720 function alignMemoryPage(x) {
 721   return ((x+4095)>>12)<<12;
 722 }
 723
 724 var HEAP;
 725 var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
 726
 727 var STACK_ROOT, STACKTOP, STACK_MAX;
 728 var STATICTOP;
 729 function enlargeMemory() {
 730   abort('Cannot enlarge memory arrays. Adjust TOTAL_MEMORY (currently ' + TOTAL_MEMORY + ') or compile with ALLOW_MEMORY_GROWTH');
 731 }
 732
 733 var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
 734 var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 10485760;
 735 var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
 736
 737 // Initialize the runtime's memory
 738 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 739   assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
 740          'Cannot fallback to non-typed array case: Code is too specialized');
 741
 742   var buffer = new ArrayBuffer(TOTAL_MEMORY);
 743   HEAP8 = new Int8Array(buffer);
 744   HEAP16 = new Int16Array(buffer);
 745   HEAP32 = new Int32Array(buffer);
 746   HEAPU8 = new Uint8Array(buffer);
 747   HEAPU16 = new Uint16Array(buffer);
 748   HEAPU32 = new Uint32Array(buffer);
 749   HEAPF32 = new Float32Array(buffer);
 750   HEAPF64 = new Float64Array(buffer);
 751
 752   // Endianness check (note: assumes compiler arch was little-endian)
 753   HEAP32[0] = 255;
 754   assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
 755
 756 Module['HEAP'] = HEAP;
 757 Module['HEAP8'] = HEAP8;
 758 Module['HEAP16'] = HEAP16;
 759 Module['HEAP32'] = HEAP32;
 760 Module['HEAPU8'] = HEAPU8;
 761 Module['HEAPU16'] = HEAPU16;
 762 Module['HEAPU32'] = HEAPU32;
 763 Module['HEAPF32'] = HEAPF32;
 764 Module['HEAPF64'] = HEAPF64;
 765
 766 STACK_ROOT = STACKTOP = Runtime.alignMemory(1);
 767 STACK_MAX = STACK_ROOT + TOTAL_STACK;
 768
 769 var tempDoublePtr = Runtime.alignMemory(STACK_MAX, 8);
 770 var tempDoubleI8  = HEAP8.subarray(tempDoublePtr);
 771 var tempDoubleI32 = HEAP32.subarray(tempDoublePtr >> 2);
 772 var tempDoubleF32 = HEAPF32.subarray(tempDoublePtr >> 2);
 773 var tempDoubleF64 = HEAPF64.subarray(tempDoublePtr >> 3);
 774 function copyTempFloat(ptr) { // functions, because inlining this code is increases code size too much
 775   tempDoubleI8[0] = HEAP8[ptr];
 776   tempDoubleI8[1] = HEAP8[ptr+1];
 777   tempDoubleI8[2] = HEAP8[ptr+2];
 778   tempDoubleI8[3] = HEAP8[ptr+3];
 779 }
 780 function copyTempDouble(ptr) {
 781   tempDoubleI8[0] = HEAP8[ptr];
 782   tempDoubleI8[1] = HEAP8[ptr+1];
 783   tempDoubleI8[2] = HEAP8[ptr+2];
 784   tempDoubleI8[3] = HEAP8[ptr+3];
 785   tempDoubleI8[4] = HEAP8[ptr+4];
 786   tempDoubleI8[5] = HEAP8[ptr+5];
 787   tempDoubleI8[6] = HEAP8[ptr+6];
 788   tempDoubleI8[7] = HEAP8[ptr+7];
 789 }
 790 STACK_MAX = tempDoublePtr + 8;
 791
 792 STATICTOP = alignMemoryPage(STACK_MAX);
 793
 794 assert(STATICTOP < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY
 795
 796 var nullString = allocate(intArrayFromString('(null)'), 'i8', ALLOC_STATIC);
 797
 798 function callRuntimeCallbacks(callbacks) {
 799   while(callbacks.length > 0) {
 800     var callback = callbacks.shift();
 801     var func = callback.func;
 802     if (typeof func === 'number') {
 803       func = FUNCTION_TABLE[func];
 804     }
 805     func(callback.arg === undefined ? null : callback.arg);
 806   }
 807 }
 808
 809 var __ATINIT__ = []; // functions called during startup
 810 var __ATMAIN__ = []; // functions called when main() is to be run
 811 var __ATEXIT__ = []; // functions called during shutdown
 812
 813 function initRuntime() {
 814   callRuntimeCallbacks(__ATINIT__);
 815 }
 816 function preMain() {
 817   callRuntimeCallbacks(__ATMAIN__);
 818 }
 819 function exitRuntime() {
 820   callRuntimeCallbacks(__ATEXIT__);
 821
 822   // Print summary of correction activity
 823   CorrectionsMonitor.print();
 824 }
 825
 826 function String_len(ptr) {
 827   var i = ptr;
 828   while (HEAP8[(i++)]) {}; // Note: should be |!= 0|, technically. But this helps catch bugs with undefineds
 829   return i - ptr - 1;
 830 }
 831 Module['String_len'] = String_len;
 832
 833 // Tools
 834
 835 // This processes a JS string into a C-line array of numbers, 0-terminated.
 836 // For LLVM-originating strings, see parser.js:parseLLVMString function
 837 function intArrayFromString(stringy, dontAddNull, length /* optional */) {
 838   var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
 839   if (length) {
 840     ret.length = length;
 841   }
 842   if (!dontAddNull) {
 843     ret.push(0);
 844   }
 845   return ret;
 846 }
 847 Module['intArrayFromString'] = intArrayFromString;
 848
 849 function intArrayToString(array) {
 850   var ret = [];
 851   for (var i = 0; i < array.length; i++) {
 852     var chr = array[i];
 853     if (chr > 0xFF) {
 854         assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ')  at offset ' + i + ' not in 0x00-0xFF.');
 855       chr &= 0xFF;
 856     }
 857     ret.push(String.fromCharCode(chr));
 858   }
 859   return ret.join('');
 860 }
 861 Module['intArrayToString'] = intArrayToString;
 862
 863 // Write a Javascript array to somewhere in the heap
 864 function writeStringToMemory(string, buffer, dontAddNull) {
 865   var array = intArrayFromString(string, dontAddNull);
 866   var i = 0;
 867   while (i < array.length) {
 868     var chr = array[i];
 869     HEAP8[((buffer)+(i))]=chr
 870     i = i + 1;
 871   }
 872 }
 873 Module['writeStringToMemory'] = writeStringToMemory;
 874
 875 function writeArrayToMemory(array, buffer) {
 876   for (var i = 0; i < array.length; i++) {
 877     HEAP8[((buffer)+(i))]=array[i];
 878   }
 879 }
 880 Module['writeArrayToMemory'] = writeArrayToMemory;
 881
 882 var STRING_TABLE = [];
 883
 884 function unSign(value, bits, ignore, sig) {
 885   if (value >= 0) {
 886     return value;
 887   }
 888   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
 889                     : Math.pow(2, bits)         + value;
 890   // TODO: clean up previous line
 891 }
 892 function reSign(value, bits, ignore, sig) {
 893   if (value <= 0) {
 894     return value;
 895   }
 896   var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
 897                         : Math.pow(2, bits-1);
 898   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
 899                                                        // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
 900                                                        // TODO: In i64 mode 1, resign the two parts separately and safely
 901     value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
 902   }
 903   return value;
 904 }
 905
 906 // A counter of dependencies for calling run(). If we need to
 907 // do asynchronous work before running, increment this and
 908 // decrement it. Incrementing must happen in a place like
 909 // PRE_RUN_ADDITIONS (used by emcc to add file preloading).
 910 // Note that you can add dependencies in preRun, even though
 911 // it happens right before run - run will be postponed until
 912 // the dependencies are met.
 913 var runDependencies = 0;
 914 var runDependencyTracking = {};
 915 var calledRun = false;
 916 var runDependencyWatcher = null;
 917 function addRunDependency(id) {
 918   runDependencies++;
 919   if (Module['monitorRunDependencies']) {
 920     Module['monitorRunDependencies'](runDependencies);
 921   }
 922   if (id) {
 923     assert(!runDependencyTracking[id]);
 924     runDependencyTracking[id] = 1;
 925     if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
 926       // Check for missing dependencies every few seconds
 927       runDependencyWatcher = setInterval(function() {
 928         var shown = false;
 929         for (var dep in runDependencyTracking) {
 930           if (!shown) {
 931             shown = true;
 932             Module.printErr('still waiting on run dependencies:');
 933           }
 934           Module.printErr('dependency: ' + dep);
 935         }
 936         if (shown) {
 937           Module.printErr('(end of list)');
 938         }
 939       }, 6000);
 940     }
 941   } else {
 942     Module.printErr('warning: run dependency added without ID');
 943   }
 944 }
 945 Module['addRunDependency'] = addRunDependency;
 946 function removeRunDependency(id) {
 947   runDependencies--;
 948   if (Module['monitorRunDependencies']) {
 949     Module['monitorRunDependencies'](runDependencies);
 950   }
 951   if (id) {
 952     assert(runDependencyTracking[id]);
 953     delete runDependencyTracking[id];
 954   } else {
 955     Module.printErr('warning: run dependency removed without ID');
 956   }
 957   if (runDependencies == 0) {
 958     if (runDependencyWatcher !== null) {
 959       clearInterval(runDependencyWatcher);
 960       runDependencyWatcher = null;
 961     }
 962     if (!calledRun) run();
 963   }
 964 }
 965 Module['removeRunDependency'] = removeRunDependency;
 966
 967 Module["preloadedImages"] = {}; // maps url to image data
 968 Module["preloadedAudios"] = {}; // maps url to audio data
 969
 970 // === Body ===
 971
 972
 973
 974
 975 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
 976 // Note: Some Emscripten settings may limit the speed of the generated code.
 977
 978 function _qc_program_code_remove($self, $idx) {
 979   ;
 980   var __label__;
 981   __label__ = 2;
 982   while(1) switch(__label__) {
 983     case 2:
 984       var $1;
 985       var $2;
 986       var $3;
 987       var $i;
 988       var $reall;
 989       $2=$self;
 990       $3=$idx;
 991       var $4=$3;
 992       var $5=$2;
 993       var $6=(($5+8)|0);
 994       var $7=HEAP32[(($6)>>2)];
 995       var $8=(($4)>>>0) >= (($7)>>>0);
 996       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
 997     case 3:
 998       $1=1;
 999       __label__ = 13; break;
1000     case 4:
1001       var $11=$3;
1002       $i=$11;
1003       __label__ = 5; break;
1004     case 5:
1005       var $13=$i;
1006       var $14=$2;
1007       var $15=(($14+8)|0);
1008       var $16=HEAP32[(($15)>>2)];
1009       var $17=((($16)-(1))|0);
1010       var $18=(($13)>>>0) < (($17)>>>0);
1011       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1012     case 6:
1013       var $20=$i;
1014       var $21=$2;
1015       var $22=(($21+4)|0);
1016       var $23=HEAP32[(($22)>>2)];
1017       var $24=(($23+($20<<3))|0);
1018       var $25=$i;
1019       var $26=((($25)+(1))|0);
1020       var $27=$2;
1021       var $28=(($27+4)|0);
1022       var $29=HEAP32[(($28)>>2)];
1023       var $30=(($29+($26<<3))|0);
1024       var $31=$24;
1025       var $32=$30;
1026       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)];
1027       __label__ = 7; break;
1028     case 7:
1029       var $34=$i;
1030       var $35=((($34)+(1))|0);
1031       $i=$35;
1032       __label__ = 5; break;
1033     case 8:
1034       var $37=$2;
1035       var $38=(($37+8)|0);
1036       var $39=HEAP32[(($38)>>2)];
1037       var $40=((($39)-(1))|0);
1038       HEAP32[(($38)>>2)]=$40;
1039       var $41=$2;
1040       var $42=(($41+8)|0);
1041       var $43=HEAP32[(($42)>>2)];
1042       var $44=$2;
1043       var $45=(($44+8)|0);
1044       var $46=HEAP32[(($45)>>2)];
1045       var $47=Math.floor(((($46)>>>0))/(2));
1046       var $48=(($43)>>>0) < (($47)>>>0);
1047       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1048     case 9:
1049       var $50=$2;
1050       var $51=(($50+12)|0);
1051       var $52=HEAP32[(($51)>>2)];
1052       var $53=Math.floor(((($52)>>>0))/(2));
1053       HEAP32[(($51)>>2)]=$53;
1054       var $54=$2;
1055       var $55=(($54+8)|0);
1056       var $56=HEAP32[(($55)>>2)];
1057       var $57=((($56<<3))|0);
1058       var $58=_util_memory_a($57, 32, ((STRING_TABLE.__str)|0));
1059       var $59=$58;
1060       $reall=$59;
1061       var $60=$reall;
1062       var $61=(($60)|0)!=0;
1063       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1064     case 10:
1065       $1=0;
1066       __label__ = 13; break;
1067     case 11:
1068       var $64=$reall;
1069       var $65=$64;
1070       var $66=$2;
1071       var $67=(($66+4)|0);
1072       var $68=HEAP32[(($67)>>2)];
1073       var $69=$68;
1074       var $70=$2;
1075       var $71=(($70+8)|0);
1076       var $72=HEAP32[(($71)>>2)];
1077       var $73=((($72<<3))|0);
1078       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 2);
1079       var $74=$2;
1080       var $75=(($74+4)|0);
1081       var $76=HEAP32[(($75)>>2)];
1082       var $77=$76;
1083       _util_memory_d($77, 32, ((STRING_TABLE.__str)|0));
1084       var $78=$reall;
1085       var $79=$2;
1086       var $80=(($79+4)|0);
1087       HEAP32[(($80)>>2)]=$78;
1088       __label__ = 12; break;
1089     case 12:
1090       $1=1;
1091       __label__ = 13; break;
1092     case 13:
1093       var $83=$1;
1094       ;
1095       return $83;
1096     default: assert(0, "bad label: " + __label__);
1097   }
1098 }
1099 _qc_program_code_remove["X"]=1;
1100
1101 function _qc_program_code_add($self, $f) {
1102   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1103   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)];
1104   var __label__;
1105   __label__ = 2;
1106   while(1) switch(__label__) {
1107     case 2:
1108       var $1;
1109       var $2;
1110       var $reall;
1111       $2=$self;
1112       var $3=$2;
1113       var $4=(($3+8)|0);
1114       var $5=HEAP32[(($4)>>2)];
1115       var $6=$2;
1116       var $7=(($6+12)|0);
1117       var $8=HEAP32[(($7)>>2)];
1118       var $9=(($5)|0)==(($8)|0);
1119       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1120     case 3:
1121       var $11=$2;
1122       var $12=(($11+12)|0);
1123       var $13=HEAP32[(($12)>>2)];
1124       var $14=(($13)|0)!=0;
1125       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1126     case 4:
1127       var $16=$2;
1128       var $17=(($16+12)|0);
1129       HEAP32[(($17)>>2)]=16;
1130       __label__ = 6; break;
1131     case 5:
1132       var $19=$2;
1133       var $20=(($19+12)|0);
1134       var $21=HEAP32[(($20)>>2)];
1135       var $22=((($21<<1))|0);
1136       HEAP32[(($20)>>2)]=$22;
1137       __label__ = 6; break;
1138     case 6:
1139       var $24=$2;
1140       var $25=(($24+12)|0);
1141       var $26=HEAP32[(($25)>>2)];
1142       var $27=((($26<<3))|0);
1143       var $28=_util_memory_a($27, 32, ((STRING_TABLE.__str)|0));
1144       var $29=$28;
1145       $reall=$29;
1146       var $30=$reall;
1147       var $31=(($30)|0)!=0;
1148       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1149     case 7:
1150       $1=0;
1151       __label__ = 10; break;
1152     case 8:
1153       var $34=$reall;
1154       var $35=$34;
1155       var $36=$2;
1156       var $37=(($36+4)|0);
1157       var $38=HEAP32[(($37)>>2)];
1158       var $39=$38;
1159       var $40=$2;
1160       var $41=(($40+8)|0);
1161       var $42=HEAP32[(($41)>>2)];
1162       var $43=((($42<<3))|0);
1163       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 2);
1164       var $44=$2;
1165       var $45=(($44+4)|0);
1166       var $46=HEAP32[(($45)>>2)];
1167       var $47=$46;
1168       _util_memory_d($47, 32, ((STRING_TABLE.__str)|0));
1169       var $48=$reall;
1170       var $49=$2;
1171       var $50=(($49+4)|0);
1172       HEAP32[(($50)>>2)]=$48;
1173       __label__ = 9; break;
1174     case 9:
1175       var $52=$2;
1176       var $53=(($52+8)|0);
1177       var $54=HEAP32[(($53)>>2)];
1178       var $55=((($54)+(1))|0);
1179       HEAP32[(($53)>>2)]=$55;
1180       var $56=$2;
1181       var $57=(($56+4)|0);
1182       var $58=HEAP32[(($57)>>2)];
1183       var $59=(($58+($54<<3))|0);
1184       var $60=$59;
1185       var $61=$f;
1186       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)];
1187       $1=1;
1188       __label__ = 10; break;
1189     case 10:
1190       var $63=$1;
1191       STACKTOP = __stackBase__;
1192       return $63;
1193     default: assert(0, "bad label: " + __label__);
1194   }
1195 }
1196 _qc_program_code_add["X"]=1;
1197
1198 function _qc_program_defs_remove($self, $idx) {
1199   ;
1200   var __label__;
1201   __label__ = 2;
1202   while(1) switch(__label__) {
1203     case 2:
1204       var $1;
1205       var $2;
1206       var $3;
1207       var $i;
1208       var $reall;
1209       $2=$self;
1210       $3=$idx;
1211       var $4=$3;
1212       var $5=$2;
1213       var $6=(($5+20)|0);
1214       var $7=HEAP32[(($6)>>2)];
1215       var $8=(($4)>>>0) >= (($7)>>>0);
1216       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1217     case 3:
1218       $1=1;
1219       __label__ = 13; break;
1220     case 4:
1221       var $11=$3;
1222       $i=$11;
1223       __label__ = 5; break;
1224     case 5:
1225       var $13=$i;
1226       var $14=$2;
1227       var $15=(($14+20)|0);
1228       var $16=HEAP32[(($15)>>2)];
1229       var $17=((($16)-(1))|0);
1230       var $18=(($13)>>>0) < (($17)>>>0);
1231       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1232     case 6:
1233       var $20=$i;
1234       var $21=$2;
1235       var $22=(($21+16)|0);
1236       var $23=HEAP32[(($22)>>2)];
1237       var $24=(($23+($20<<3))|0);
1238       var $25=$i;
1239       var $26=((($25)+(1))|0);
1240       var $27=$2;
1241       var $28=(($27+16)|0);
1242       var $29=HEAP32[(($28)>>2)];
1243       var $30=(($29+($26<<3))|0);
1244       var $31=$24;
1245       var $32=$30;
1246       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)];
1247       __label__ = 7; break;
1248     case 7:
1249       var $34=$i;
1250       var $35=((($34)+(1))|0);
1251       $i=$35;
1252       __label__ = 5; break;
1253     case 8:
1254       var $37=$2;
1255       var $38=(($37+20)|0);
1256       var $39=HEAP32[(($38)>>2)];
1257       var $40=((($39)-(1))|0);
1258       HEAP32[(($38)>>2)]=$40;
1259       var $41=$2;
1260       var $42=(($41+20)|0);
1261       var $43=HEAP32[(($42)>>2)];
1262       var $44=$2;
1263       var $45=(($44+20)|0);
1264       var $46=HEAP32[(($45)>>2)];
1265       var $47=Math.floor(((($46)>>>0))/(2));
1266       var $48=(($43)>>>0) < (($47)>>>0);
1267       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1268     case 9:
1269       var $50=$2;
1270       var $51=(($50+24)|0);
1271       var $52=HEAP32[(($51)>>2)];
1272       var $53=Math.floor(((($52)>>>0))/(2));
1273       HEAP32[(($51)>>2)]=$53;
1274       var $54=$2;
1275       var $55=(($54+20)|0);
1276       var $56=HEAP32[(($55)>>2)];
1277       var $57=((($56<<3))|0);
1278       var $58=_util_memory_a($57, 33, ((STRING_TABLE.__str)|0));
1279       var $59=$58;
1280       $reall=$59;
1281       var $60=$reall;
1282       var $61=(($60)|0)!=0;
1283       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1284     case 10:
1285       $1=0;
1286       __label__ = 13; break;
1287     case 11:
1288       var $64=$reall;
1289       var $65=$64;
1290       var $66=$2;
1291       var $67=(($66+16)|0);
1292       var $68=HEAP32[(($67)>>2)];
1293       var $69=$68;
1294       var $70=$2;
1295       var $71=(($70+20)|0);
1296       var $72=HEAP32[(($71)>>2)];
1297       var $73=((($72<<3))|0);
1298       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1299       var $74=$2;
1300       var $75=(($74+16)|0);
1301       var $76=HEAP32[(($75)>>2)];
1302       var $77=$76;
1303       _util_memory_d($77, 33, ((STRING_TABLE.__str)|0));
1304       var $78=$reall;
1305       var $79=$2;
1306       var $80=(($79+16)|0);
1307       HEAP32[(($80)>>2)]=$78;
1308       __label__ = 12; break;
1309     case 12:
1310       $1=1;
1311       __label__ = 13; break;
1312     case 13:
1313       var $83=$1;
1314       ;
1315       return $83;
1316     default: assert(0, "bad label: " + __label__);
1317   }
1318 }
1319 _qc_program_defs_remove["X"]=1;
1320
1321 function _qc_program_defs_add($self, $f) {
1322   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1323   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)];
1324   var __label__;
1325   __label__ = 2;
1326   while(1) switch(__label__) {
1327     case 2:
1328       var $1;
1329       var $2;
1330       var $reall;
1331       $2=$self;
1332       var $3=$2;
1333       var $4=(($3+20)|0);
1334       var $5=HEAP32[(($4)>>2)];
1335       var $6=$2;
1336       var $7=(($6+24)|0);
1337       var $8=HEAP32[(($7)>>2)];
1338       var $9=(($5)|0)==(($8)|0);
1339       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1340     case 3:
1341       var $11=$2;
1342       var $12=(($11+24)|0);
1343       var $13=HEAP32[(($12)>>2)];
1344       var $14=(($13)|0)!=0;
1345       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1346     case 4:
1347       var $16=$2;
1348       var $17=(($16+24)|0);
1349       HEAP32[(($17)>>2)]=16;
1350       __label__ = 6; break;
1351     case 5:
1352       var $19=$2;
1353       var $20=(($19+24)|0);
1354       var $21=HEAP32[(($20)>>2)];
1355       var $22=((($21<<1))|0);
1356       HEAP32[(($20)>>2)]=$22;
1357       __label__ = 6; break;
1358     case 6:
1359       var $24=$2;
1360       var $25=(($24+24)|0);
1361       var $26=HEAP32[(($25)>>2)];
1362       var $27=((($26<<3))|0);
1363       var $28=_util_memory_a($27, 33, ((STRING_TABLE.__str)|0));
1364       var $29=$28;
1365       $reall=$29;
1366       var $30=$reall;
1367       var $31=(($30)|0)!=0;
1368       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1369     case 7:
1370       $1=0;
1371       __label__ = 10; break;
1372     case 8:
1373       var $34=$reall;
1374       var $35=$34;
1375       var $36=$2;
1376       var $37=(($36+16)|0);
1377       var $38=HEAP32[(($37)>>2)];
1378       var $39=$38;
1379       var $40=$2;
1380       var $41=(($40+20)|0);
1381       var $42=HEAP32[(($41)>>2)];
1382       var $43=((($42<<3))|0);
1383       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1384       var $44=$2;
1385       var $45=(($44+16)|0);
1386       var $46=HEAP32[(($45)>>2)];
1387       var $47=$46;
1388       _util_memory_d($47, 33, ((STRING_TABLE.__str)|0));
1389       var $48=$reall;
1390       var $49=$2;
1391       var $50=(($49+16)|0);
1392       HEAP32[(($50)>>2)]=$48;
1393       __label__ = 9; break;
1394     case 9:
1395       var $52=$2;
1396       var $53=(($52+20)|0);
1397       var $54=HEAP32[(($53)>>2)];
1398       var $55=((($54)+(1))|0);
1399       HEAP32[(($53)>>2)]=$55;
1400       var $56=$2;
1401       var $57=(($56+16)|0);
1402       var $58=HEAP32[(($57)>>2)];
1403       var $59=(($58+($54<<3))|0);
1404       var $60=$59;
1405       var $61=$f;
1406       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)];
1407       $1=1;
1408       __label__ = 10; break;
1409     case 10:
1410       var $63=$1;
1411       STACKTOP = __stackBase__;
1412       return $63;
1413     default: assert(0, "bad label: " + __label__);
1414   }
1415 }
1416 _qc_program_defs_add["X"]=1;
1417
1418 function _qc_program_fields_remove($self, $idx) {
1419   ;
1420   var __label__;
1421   __label__ = 2;
1422   while(1) switch(__label__) {
1423     case 2:
1424       var $1;
1425       var $2;
1426       var $3;
1427       var $i;
1428       var $reall;
1429       $2=$self;
1430       $3=$idx;
1431       var $4=$3;
1432       var $5=$2;
1433       var $6=(($5+32)|0);
1434       var $7=HEAP32[(($6)>>2)];
1435       var $8=(($4)>>>0) >= (($7)>>>0);
1436       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1437     case 3:
1438       $1=1;
1439       __label__ = 13; break;
1440     case 4:
1441       var $11=$3;
1442       $i=$11;
1443       __label__ = 5; break;
1444     case 5:
1445       var $13=$i;
1446       var $14=$2;
1447       var $15=(($14+32)|0);
1448       var $16=HEAP32[(($15)>>2)];
1449       var $17=((($16)-(1))|0);
1450       var $18=(($13)>>>0) < (($17)>>>0);
1451       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1452     case 6:
1453       var $20=$i;
1454       var $21=$2;
1455       var $22=(($21+28)|0);
1456       var $23=HEAP32[(($22)>>2)];
1457       var $24=(($23+($20<<3))|0);
1458       var $25=$i;
1459       var $26=((($25)+(1))|0);
1460       var $27=$2;
1461       var $28=(($27+28)|0);
1462       var $29=HEAP32[(($28)>>2)];
1463       var $30=(($29+($26<<3))|0);
1464       var $31=$24;
1465       var $32=$30;
1466       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)];
1467       __label__ = 7; break;
1468     case 7:
1469       var $34=$i;
1470       var $35=((($34)+(1))|0);
1471       $i=$35;
1472       __label__ = 5; break;
1473     case 8:
1474       var $37=$2;
1475       var $38=(($37+32)|0);
1476       var $39=HEAP32[(($38)>>2)];
1477       var $40=((($39)-(1))|0);
1478       HEAP32[(($38)>>2)]=$40;
1479       var $41=$2;
1480       var $42=(($41+32)|0);
1481       var $43=HEAP32[(($42)>>2)];
1482       var $44=$2;
1483       var $45=(($44+32)|0);
1484       var $46=HEAP32[(($45)>>2)];
1485       var $47=Math.floor(((($46)>>>0))/(2));
1486       var $48=(($43)>>>0) < (($47)>>>0);
1487       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1488     case 9:
1489       var $50=$2;
1490       var $51=(($50+36)|0);
1491       var $52=HEAP32[(($51)>>2)];
1492       var $53=Math.floor(((($52)>>>0))/(2));
1493       HEAP32[(($51)>>2)]=$53;
1494       var $54=$2;
1495       var $55=(($54+32)|0);
1496       var $56=HEAP32[(($55)>>2)];
1497       var $57=((($56<<3))|0);
1498       var $58=_util_memory_a($57, 34, ((STRING_TABLE.__str)|0));
1499       var $59=$58;
1500       $reall=$59;
1501       var $60=$reall;
1502       var $61=(($60)|0)!=0;
1503       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1504     case 10:
1505       $1=0;
1506       __label__ = 13; break;
1507     case 11:
1508       var $64=$reall;
1509       var $65=$64;
1510       var $66=$2;
1511       var $67=(($66+28)|0);
1512       var $68=HEAP32[(($67)>>2)];
1513       var $69=$68;
1514       var $70=$2;
1515       var $71=(($70+32)|0);
1516       var $72=HEAP32[(($71)>>2)];
1517       var $73=((($72<<3))|0);
1518       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1519       var $74=$2;
1520       var $75=(($74+28)|0);
1521       var $76=HEAP32[(($75)>>2)];
1522       var $77=$76;
1523       _util_memory_d($77, 34, ((STRING_TABLE.__str)|0));
1524       var $78=$reall;
1525       var $79=$2;
1526       var $80=(($79+28)|0);
1527       HEAP32[(($80)>>2)]=$78;
1528       __label__ = 12; break;
1529     case 12:
1530       $1=1;
1531       __label__ = 13; break;
1532     case 13:
1533       var $83=$1;
1534       ;
1535       return $83;
1536     default: assert(0, "bad label: " + __label__);
1537   }
1538 }
1539 _qc_program_fields_remove["X"]=1;
1540
1541 function _qc_program_fields_add($self, $f) {
1542   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1543   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)];
1544   var __label__;
1545   __label__ = 2;
1546   while(1) switch(__label__) {
1547     case 2:
1548       var $1;
1549       var $2;
1550       var $reall;
1551       $2=$self;
1552       var $3=$2;
1553       var $4=(($3+32)|0);
1554       var $5=HEAP32[(($4)>>2)];
1555       var $6=$2;
1556       var $7=(($6+36)|0);
1557       var $8=HEAP32[(($7)>>2)];
1558       var $9=(($5)|0)==(($8)|0);
1559       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1560     case 3:
1561       var $11=$2;
1562       var $12=(($11+36)|0);
1563       var $13=HEAP32[(($12)>>2)];
1564       var $14=(($13)|0)!=0;
1565       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1566     case 4:
1567       var $16=$2;
1568       var $17=(($16+36)|0);
1569       HEAP32[(($17)>>2)]=16;
1570       __label__ = 6; break;
1571     case 5:
1572       var $19=$2;
1573       var $20=(($19+36)|0);
1574       var $21=HEAP32[(($20)>>2)];
1575       var $22=((($21<<1))|0);
1576       HEAP32[(($20)>>2)]=$22;
1577       __label__ = 6; break;
1578     case 6:
1579       var $24=$2;
1580       var $25=(($24+36)|0);
1581       var $26=HEAP32[(($25)>>2)];
1582       var $27=((($26<<3))|0);
1583       var $28=_util_memory_a($27, 34, ((STRING_TABLE.__str)|0));
1584       var $29=$28;
1585       $reall=$29;
1586       var $30=$reall;
1587       var $31=(($30)|0)!=0;
1588       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1589     case 7:
1590       $1=0;
1591       __label__ = 10; break;
1592     case 8:
1593       var $34=$reall;
1594       var $35=$34;
1595       var $36=$2;
1596       var $37=(($36+28)|0);
1597       var $38=HEAP32[(($37)>>2)];
1598       var $39=$38;
1599       var $40=$2;
1600       var $41=(($40+32)|0);
1601       var $42=HEAP32[(($41)>>2)];
1602       var $43=((($42<<3))|0);
1603       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1604       var $44=$2;
1605       var $45=(($44+28)|0);
1606       var $46=HEAP32[(($45)>>2)];
1607       var $47=$46;
1608       _util_memory_d($47, 34, ((STRING_TABLE.__str)|0));
1609       var $48=$reall;
1610       var $49=$2;
1611       var $50=(($49+28)|0);
1612       HEAP32[(($50)>>2)]=$48;
1613       __label__ = 9; break;
1614     case 9:
1615       var $52=$2;
1616       var $53=(($52+32)|0);
1617       var $54=HEAP32[(($53)>>2)];
1618       var $55=((($54)+(1))|0);
1619       HEAP32[(($53)>>2)]=$55;
1620       var $56=$2;
1621       var $57=(($56+28)|0);
1622       var $58=HEAP32[(($57)>>2)];
1623       var $59=(($58+($54<<3))|0);
1624       var $60=$59;
1625       var $61=$f;
1626       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)];
1627       $1=1;
1628       __label__ = 10; break;
1629     case 10:
1630       var $63=$1;
1631       STACKTOP = __stackBase__;
1632       return $63;
1633     default: assert(0, "bad label: " + __label__);
1634   }
1635 }
1636 _qc_program_fields_add["X"]=1;
1637
1638 function _qc_program_functions_remove($self, $idx) {
1639   ;
1640   var __label__;
1641   __label__ = 2;
1642   while(1) switch(__label__) {
1643     case 2:
1644       var $1;
1645       var $2;
1646       var $3;
1647       var $i;
1648       var $reall;
1649       $2=$self;
1650       $3=$idx;
1651       var $4=$3;
1652       var $5=$2;
1653       var $6=(($5+44)|0);
1654       var $7=HEAP32[(($6)>>2)];
1655       var $8=(($4)>>>0) >= (($7)>>>0);
1656       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1657     case 3:
1658       $1=1;
1659       __label__ = 13; break;
1660     case 4:
1661       var $11=$3;
1662       $i=$11;
1663       __label__ = 5; break;
1664     case 5:
1665       var $13=$i;
1666       var $14=$2;
1667       var $15=(($14+44)|0);
1668       var $16=HEAP32[(($15)>>2)];
1669       var $17=((($16)-(1))|0);
1670       var $18=(($13)>>>0) < (($17)>>>0);
1671       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1672     case 6:
1673       var $20=$i;
1674       var $21=$2;
1675       var $22=(($21+40)|0);
1676       var $23=HEAP32[(($22)>>2)];
1677       var $24=(($23+($20)*(36))|0);
1678       var $25=$i;
1679       var $26=((($25)+(1))|0);
1680       var $27=$2;
1681       var $28=(($27+40)|0);
1682       var $29=HEAP32[(($28)>>2)];
1683       var $30=(($29+($26)*(36))|0);
1684       var $31=$24;
1685       var $32=$30;
1686       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++) {
1687         HEAP32[$$dest] = HEAP32[$$src]
1688       };
1689       __label__ = 7; break;
1690     case 7:
1691       var $34=$i;
1692       var $35=((($34)+(1))|0);
1693       $i=$35;
1694       __label__ = 5; break;
1695     case 8:
1696       var $37=$2;
1697       var $38=(($37+44)|0);
1698       var $39=HEAP32[(($38)>>2)];
1699       var $40=((($39)-(1))|0);
1700       HEAP32[(($38)>>2)]=$40;
1701       var $41=$2;
1702       var $42=(($41+44)|0);
1703       var $43=HEAP32[(($42)>>2)];
1704       var $44=$2;
1705       var $45=(($44+44)|0);
1706       var $46=HEAP32[(($45)>>2)];
1707       var $47=Math.floor(((($46)>>>0))/(2));
1708       var $48=(($43)>>>0) < (($47)>>>0);
1709       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
1710     case 9:
1711       var $50=$2;
1712       var $51=(($50+48)|0);
1713       var $52=HEAP32[(($51)>>2)];
1714       var $53=Math.floor(((($52)>>>0))/(2));
1715       HEAP32[(($51)>>2)]=$53;
1716       var $54=$2;
1717       var $55=(($54+44)|0);
1718       var $56=HEAP32[(($55)>>2)];
1719       var $57=((($56)*(36))|0);
1720       var $58=_util_memory_a($57, 35, ((STRING_TABLE.__str)|0));
1721       var $59=$58;
1722       $reall=$59;
1723       var $60=$reall;
1724       var $61=(($60)|0)!=0;
1725       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
1726     case 10:
1727       $1=0;
1728       __label__ = 13; break;
1729     case 11:
1730       var $64=$reall;
1731       var $65=$64;
1732       var $66=$2;
1733       var $67=(($66+40)|0);
1734       var $68=HEAP32[(($67)>>2)];
1735       var $69=$68;
1736       var $70=$2;
1737       var $71=(($70+44)|0);
1738       var $72=HEAP32[(($71)>>2)];
1739       var $73=((($72)*(36))|0);
1740       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
1741       var $74=$2;
1742       var $75=(($74+40)|0);
1743       var $76=HEAP32[(($75)>>2)];
1744       var $77=$76;
1745       _util_memory_d($77, 35, ((STRING_TABLE.__str)|0));
1746       var $78=$reall;
1747       var $79=$2;
1748       var $80=(($79+40)|0);
1749       HEAP32[(($80)>>2)]=$78;
1750       __label__ = 12; break;
1751     case 12:
1752       $1=1;
1753       __label__ = 13; break;
1754     case 13:
1755       var $83=$1;
1756       ;
1757       return $83;
1758     default: assert(0, "bad label: " + __label__);
1759   }
1760 }
1761 _qc_program_functions_remove["X"]=1;
1762
1763 function _qc_program_functions_add($self, $f) {
1764   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
1765   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++) {
1766   HEAP32[$$dest] = HEAP32[$$src]
1767 };
1768   var __label__;
1769   __label__ = 2;
1770   while(1) switch(__label__) {
1771     case 2:
1772       var $1;
1773       var $2;
1774       var $reall;
1775       $2=$self;
1776       var $3=$2;
1777       var $4=(($3+44)|0);
1778       var $5=HEAP32[(($4)>>2)];
1779       var $6=$2;
1780       var $7=(($6+48)|0);
1781       var $8=HEAP32[(($7)>>2)];
1782       var $9=(($5)|0)==(($8)|0);
1783       if ($9) { __label__ = 3; break; } else { __label__ = 9; break; }
1784     case 3:
1785       var $11=$2;
1786       var $12=(($11+48)|0);
1787       var $13=HEAP32[(($12)>>2)];
1788       var $14=(($13)|0)!=0;
1789       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
1790     case 4:
1791       var $16=$2;
1792       var $17=(($16+48)|0);
1793       HEAP32[(($17)>>2)]=16;
1794       __label__ = 6; break;
1795     case 5:
1796       var $19=$2;
1797       var $20=(($19+48)|0);
1798       var $21=HEAP32[(($20)>>2)];
1799       var $22=((($21<<1))|0);
1800       HEAP32[(($20)>>2)]=$22;
1801       __label__ = 6; break;
1802     case 6:
1803       var $24=$2;
1804       var $25=(($24+48)|0);
1805       var $26=HEAP32[(($25)>>2)];
1806       var $27=((($26)*(36))|0);
1807       var $28=_util_memory_a($27, 35, ((STRING_TABLE.__str)|0));
1808       var $29=$28;
1809       $reall=$29;
1810       var $30=$reall;
1811       var $31=(($30)|0)!=0;
1812       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
1813     case 7:
1814       $1=0;
1815       __label__ = 10; break;
1816     case 8:
1817       var $34=$reall;
1818       var $35=$34;
1819       var $36=$2;
1820       var $37=(($36+40)|0);
1821       var $38=HEAP32[(($37)>>2)];
1822       var $39=$38;
1823       var $40=$2;
1824       var $41=(($40+44)|0);
1825       var $42=HEAP32[(($41)>>2)];
1826       var $43=((($42)*(36))|0);
1827       assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4);
1828       var $44=$2;
1829       var $45=(($44+40)|0);
1830       var $46=HEAP32[(($45)>>2)];
1831       var $47=$46;
1832       _util_memory_d($47, 35, ((STRING_TABLE.__str)|0));
1833       var $48=$reall;
1834       var $49=$2;
1835       var $50=(($49+40)|0);
1836       HEAP32[(($50)>>2)]=$48;
1837       __label__ = 9; break;
1838     case 9:
1839       var $52=$2;
1840       var $53=(($52+44)|0);
1841       var $54=HEAP32[(($53)>>2)];
1842       var $55=((($54)+(1))|0);
1843       HEAP32[(($53)>>2)]=$55;
1844       var $56=$2;
1845       var $57=(($56+40)|0);
1846       var $58=HEAP32[(($57)>>2)];
1847       var $59=(($58+($54)*(36))|0);
1848       var $60=$59;
1849       var $61=$f;
1850       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++) {
1851         HEAP32[$$dest] = HEAP32[$$src]
1852       };
1853       $1=1;
1854       __label__ = 10; break;
1855     case 10:
1856       var $63=$1;
1857       STACKTOP = __stackBase__;
1858       return $63;
1859     default: assert(0, "bad label: " + __label__);
1860   }
1861 }
1862 _qc_program_functions_add["X"]=1;
1863
1864 function _qc_program_strings_remove($self, $idx) {
1865   ;
1866   var __label__;
1867   __label__ = 2;
1868   while(1) switch(__label__) {
1869     case 2:
1870       var $1;
1871       var $2;
1872       var $3;
1873       var $i;
1874       var $reall;
1875       $2=$self;
1876       $3=$idx;
1877       var $4=$3;
1878       var $5=$2;
1879       var $6=(($5+56)|0);
1880       var $7=HEAP32[(($6)>>2)];
1881       var $8=(($4)>>>0) >= (($7)>>>0);
1882       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
1883     case 3:
1884       $1=1;
1885       __label__ = 13; break;
1886     case 4:
1887       var $11=$3;
1888       $i=$11;
1889       __label__ = 5; break;
1890     case 5:
1891       var $13=$i;
1892       var $14=$2;
1893       var $15=(($14+56)|0);
1894       var $16=HEAP32[(($15)>>2)];
1895       var $17=((($16)-(1))|0);
1896       var $18=(($13)>>>0) < (($17)>>>0);
1897       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
1898     case 6:
1899       var $20=$i;
1900       var $21=((($20)+(1))|0);
1901       var $22=$2;
1902       var $23=(($22+52)|0);
1903       var $24=HEAP32[(($23)>>2)];
1904       var $25=(($24+$21)|0);
1905       var $26=HEAP8[($25)];
1906       var $27=$i;
1907       var $28=$2;
1908       var $29=(($28+52)|0);
1909       var $30=HEAP32[(($29)>>2)];
1910       var $31=(($30+$27)|0);
1911       HEAP8[($31)]=$26;
1912       __label__ = 7; break;
1913     case 7:
1914       var $33=$i;
1915       var $34=((($33)+(1))|0);
1916       $i=$34;
1917       __label__ = 5; break;
1918     case 8:
1919       var $36=$2;
1920       var $37=(($36+56)|0);
1921       var $38=HEAP32[(($37)>>2)];
1922       var $39=((($38)-(1))|0);
1923       HEAP32[(($37)>>2)]=$39;
1924       var $40=$2;
1925       var $41=(($40+56)|0);
1926       var $42=HEAP32[(($41)>>2)];
1927       var $43=$2;
1928       var $44=(($43+56)|0);
1929       var $45=HEAP32[(($44)>>2)];
1930       var $46=Math.floor(((($45)>>>0))/(2));
1931       var $47=(($42)>>>0) < (($46)>>>0);
1932       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
1933     case 9:
1934       var $49=$2;
1935       var $50=(($49+60)|0);
1936       var $51=HEAP32[(($50)>>2)];
1937       var $52=Math.floor(((($51)>>>0))/(2));
1938       HEAP32[(($50)>>2)]=$52;
1939       var $53=$2;
1940       var $54=(($53+56)|0);
1941       var $55=HEAP32[(($54)>>2)];
1942       var $56=(($55)|0);
1943       var $57=_util_memory_a($56, 36, ((STRING_TABLE.__str)|0));
1944       $reall=$57;
1945       var $58=$reall;
1946       var $59=(($58)|0)!=0;
1947       if ($59) { __label__ = 11; break; } else { __label__ = 10; break; }
1948     case 10:
1949       $1=0;
1950       __label__ = 13; break;
1951     case 11:
1952       var $62=$reall;
1953       var $63=$2;
1954       var $64=(($63+52)|0);
1955       var $65=HEAP32[(($64)>>2)];
1956       var $66=$2;
1957       var $67=(($66+56)|0);
1958       var $68=HEAP32[(($67)>>2)];
1959       var $69=(($68)|0);
1960       assert($69 % 1 === 0, 'memcpy given ' + $69 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($62, $65, $69, 1);
1961       var $70=$2;
1962       var $71=(($70+52)|0);
1963       var $72=HEAP32[(($71)>>2)];
1964       _util_memory_d($72, 36, ((STRING_TABLE.__str)|0));
1965       var $73=$reall;
1966       var $74=$2;
1967       var $75=(($74+52)|0);
1968       HEAP32[(($75)>>2)]=$73;
1969       __label__ = 12; break;
1970     case 12:
1971       $1=1;
1972       __label__ = 13; break;
1973     case 13:
1974       var $78=$1;
1975       ;
1976       return $78;
1977     default: assert(0, "bad label: " + __label__);
1978   }
1979 }
1980 _qc_program_strings_remove["X"]=1;
1981
1982 function _qc_program_strings_add($self, $f) {
1983   ;
1984   var __label__;
1985   __label__ = 2;
1986   while(1) switch(__label__) {
1987     case 2:
1988       var $1;
1989       var $2;
1990       var $3;
1991       var $reall;
1992       $2=$self;
1993       $3=$f;
1994       var $4=$2;
1995       var $5=(($4+56)|0);
1996       var $6=HEAP32[(($5)>>2)];
1997       var $7=$2;
1998       var $8=(($7+60)|0);
1999       var $9=HEAP32[(($8)>>2)];
2000       var $10=(($6)|0)==(($9)|0);
2001       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
2002     case 3:
2003       var $12=$2;
2004       var $13=(($12+60)|0);
2005       var $14=HEAP32[(($13)>>2)];
2006       var $15=(($14)|0)!=0;
2007       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
2008     case 4:
2009       var $17=$2;
2010       var $18=(($17+60)|0);
2011       HEAP32[(($18)>>2)]=16;
2012       __label__ = 6; break;
2013     case 5:
2014       var $20=$2;
2015       var $21=(($20+60)|0);
2016       var $22=HEAP32[(($21)>>2)];
2017       var $23=((($22<<1))|0);
2018       HEAP32[(($21)>>2)]=$23;
2019       __label__ = 6; break;
2020     case 6:
2021       var $25=$2;
2022       var $26=(($25+60)|0);
2023       var $27=HEAP32[(($26)>>2)];
2024       var $28=(($27)|0);
2025       var $29=_util_memory_a($28, 36, ((STRING_TABLE.__str)|0));
2026       $reall=$29;
2027       var $30=$reall;
2028       var $31=(($30)|0)!=0;
2029       if ($31) { __label__ = 8; break; } else { __label__ = 7; break; }
2030     case 7:
2031       $1=0;
2032       __label__ = 10; break;
2033     case 8:
2034       var $34=$reall;
2035       var $35=$2;
2036       var $36=(($35+52)|0);
2037       var $37=HEAP32[(($36)>>2)];
2038       var $38=$2;
2039       var $39=(($38+56)|0);
2040       var $40=HEAP32[(($39)>>2)];
2041       var $41=(($40)|0);
2042       assert($41 % 1 === 0, 'memcpy given ' + $41 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($34, $37, $41, 1);
2043       var $42=$2;
2044       var $43=(($42+52)|0);
2045       var $44=HEAP32[(($43)>>2)];
2046       _util_memory_d($44, 36, ((STRING_TABLE.__str)|0));
2047       var $45=$reall;
2048       var $46=$2;
2049       var $47=(($46+52)|0);
2050       HEAP32[(($47)>>2)]=$45;
2051       __label__ = 9; break;
2052     case 9:
2053       var $49=$3;
2054       var $50=$2;
2055       var $51=(($50+56)|0);
2056       var $52=HEAP32[(($51)>>2)];
2057       var $53=((($52)+(1))|0);
2058       HEAP32[(($51)>>2)]=$53;
2059       var $54=$2;
2060       var $55=(($54+52)|0);
2061       var $56=HEAP32[(($55)>>2)];
2062       var $57=(($56+$52)|0);
2063       HEAP8[($57)]=$49;
2064       $1=1;
2065       __label__ = 10; break;
2066     case 10:
2067       var $59=$1;
2068       ;
2069       return $59;
2070     default: assert(0, "bad label: " + __label__);
2071   }
2072 }
2073 _qc_program_strings_add["X"]=1;
2074
2075 function _qc_program_strings_append($s, $p, $c) {
2076   ;
2077   var __label__;
2078   __label__ = 2;
2079   while(1) switch(__label__) {
2080     case 2:
2081       var $1;
2082       var $2;
2083       var $3;
2084       var $4;
2085       var $reall;
2086       var $oldalloc;
2087       $2=$s;
2088       $3=$p;
2089       $4=$c;
2090       var $5=$2;
2091       var $6=(($5+56)|0);
2092       var $7=HEAP32[(($6)>>2)];
2093       var $8=$4;
2094       var $9=((($7)+($8))|0);
2095       var $10=$2;
2096       var $11=(($10+60)|0);
2097       var $12=HEAP32[(($11)>>2)];
2098       var $13=(($9)>>>0) > (($12)>>>0);
2099       if ($13) { __label__ = 3; break; } else { __label__ = 14; break; }
2100     case 3:
2101       var $15=$2;
2102       var $16=(($15+60)|0);
2103       var $17=HEAP32[(($16)>>2)];
2104       var $18=(($17)|0)!=0;
2105       if ($18) { __label__ = 8; break; } else { __label__ = 4; break; }
2106     case 4:
2107       var $20=$4;
2108       var $21=(($20)>>>0) < 16;
2109       if ($21) { __label__ = 5; break; } else { __label__ = 6; break; }
2110     case 5:
2111       var $26 = 16;__label__ = 7; break;
2112     case 6:
2113       var $24=$4;
2114       var $26 = $24;__label__ = 7; break;
2115     case 7:
2116       var $26;
2117       var $27=$2;
2118       var $28=(($27+60)|0);
2119       HEAP32[(($28)>>2)]=$26;
2120       var $29=$2;
2121       var $30=(($29+60)|0);
2122       var $31=HEAP32[(($30)>>2)];
2123       var $32=(($31)|0);
2124       var $33=_util_memory_a($32, 37, ((STRING_TABLE.__str)|0));
2125       var $34=$2;
2126       var $35=(($34+52)|0);
2127       HEAP32[(($35)>>2)]=$33;
2128       __label__ = 13; break;
2129     case 8:
2130       var $37=$2;
2131       var $38=(($37+60)|0);
2132       var $39=HEAP32[(($38)>>2)];
2133       $oldalloc=$39;
2134       var $40=$2;
2135       var $41=(($40+60)|0);
2136       var $42=HEAP32[(($41)>>2)];
2137       var $43=((($42<<1))|0);
2138       HEAP32[(($41)>>2)]=$43;
2139       var $44=$2;
2140       var $45=(($44+56)|0);
2141       var $46=HEAP32[(($45)>>2)];
2142       var $47=$4;
2143       var $48=((($46)+($47))|0);
2144       var $49=$2;
2145       var $50=(($49+60)|0);
2146       var $51=HEAP32[(($50)>>2)];
2147       var $52=(($48)>>>0) >= (($51)>>>0);
2148       if ($52) { __label__ = 9; break; } else { __label__ = 10; break; }
2149     case 9:
2150       var $54=$2;
2151       var $55=(($54+56)|0);
2152       var $56=HEAP32[(($55)>>2)];
2153       var $57=$4;
2154       var $58=((($56)+($57))|0);
2155       var $59=$2;
2156       var $60=(($59+60)|0);
2157       HEAP32[(($60)>>2)]=$58;
2158       __label__ = 10; break;
2159     case 10:
2160       var $62=$2;
2161       var $63=(($62+60)|0);
2162       var $64=HEAP32[(($63)>>2)];
2163       var $65=(($64)|0);
2164       var $66=_util_memory_a($65, 37, ((STRING_TABLE.__str)|0));
2165       $reall=$66;
2166       var $67=$reall;
2167       var $68=(($67)|0)!=0;
2168       if ($68) { __label__ = 12; break; } else { __label__ = 11; break; }
2169     case 11:
2170       var $70=$oldalloc;
2171       var $71=$2;
2172       var $72=(($71+60)|0);
2173       HEAP32[(($72)>>2)]=$70;
2174       $1=0;
2175       __label__ = 15; break;
2176     case 12:
2177       var $74=$reall;
2178       var $75=$2;
2179       var $76=(($75+52)|0);
2180       var $77=HEAP32[(($76)>>2)];
2181       var $78=$2;
2182       var $79=(($78+56)|0);
2183       var $80=HEAP32[(($79)>>2)];
2184       var $81=(($80)|0);
2185       assert($81 % 1 === 0, 'memcpy given ' + $81 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($74, $77, $81, 1);
2186       var $82=$2;
2187       var $83=(($82+52)|0);
2188       var $84=HEAP32[(($83)>>2)];
2189       _util_memory_d($84, 37, ((STRING_TABLE.__str)|0));
2190       var $85=$reall;
2191       var $86=$2;
2192       var $87=(($86+52)|0);
2193       HEAP32[(($87)>>2)]=$85;
2194       __label__ = 13; break;
2195     case 13:
2196       __label__ = 14; break;
2197     case 14:
2198       var $90=$2;
2199       var $91=(($90+56)|0);
2200       var $92=HEAP32[(($91)>>2)];
2201       var $93=$2;
2202       var $94=(($93+52)|0);
2203       var $95=HEAP32[(($94)>>2)];
2204       var $96=(($95+$92)|0);
2205       var $97=$3;
2206       var $98=$4;
2207       var $99=(($98)|0);
2208       assert($99 % 1 === 0, 'memcpy given ' + $99 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($96, $97, $99, 1);
2209       var $100=$4;
2210       var $101=$2;
2211       var $102=(($101+56)|0);
2212       var $103=HEAP32[(($102)>>2)];
2213       var $104=((($103)+($100))|0);
2214       HEAP32[(($102)>>2)]=$104;
2215       $1=1;
2216       __label__ = 15; break;
2217     case 15:
2218       var $106=$1;
2219       ;
2220       return $106;
2221     default: assert(0, "bad label: " + __label__);
2222   }
2223 }
2224 _qc_program_strings_append["X"]=1;
2225
2226 function _qc_program_strings_resize($s, $c) {
2227   ;
2228   var __label__;
2229   __label__ = 2;
2230   while(1) switch(__label__) {
2231     case 2:
2232       var $1;
2233       var $2;
2234       var $3;
2235       var $reall;
2236       $2=$s;
2237       $3=$c;
2238       var $4=$3;
2239       var $5=$2;
2240       var $6=(($5+60)|0);
2241       var $7=HEAP32[(($6)>>2)];
2242       var $8=(($4)>>>0) > (($7)>>>0);
2243       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
2244     case 3:
2245       var $10=$3;
2246       var $11=(($10)|0);
2247       var $12=_util_memory_a($11, 38, ((STRING_TABLE.__str)|0));
2248       $reall=$12;
2249       var $13=$reall;
2250       var $14=(($13)|0)!=0;
2251       if ($14) { __label__ = 5; break; } else { __label__ = 4; break; }
2252     case 4:
2253       $1=0;
2254       __label__ = 11; break;
2255     case 5:
2256       var $17=$reall;
2257       var $18=$2;
2258       var $19=(($18+52)|0);
2259       var $20=HEAP32[(($19)>>2)];
2260       var $21=$2;
2261       var $22=(($21+56)|0);
2262       var $23=HEAP32[(($22)>>2)];
2263       var $24=(($23)|0);
2264       assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($17, $20, $24, 1);
2265       var $25=$3;
2266       var $26=$2;
2267       var $27=(($26+60)|0);
2268       HEAP32[(($27)>>2)]=$25;
2269       var $28=$3;
2270       var $29=$2;
2271       var $30=(($29+56)|0);
2272       HEAP32[(($30)>>2)]=$28;
2273       var $31=$2;
2274       var $32=(($31+52)|0);
2275       var $33=HEAP32[(($32)>>2)];
2276       _util_memory_d($33, 38, ((STRING_TABLE.__str)|0));
2277       var $34=$reall;
2278       var $35=$2;
2279       var $36=(($35+52)|0);
2280       HEAP32[(($36)>>2)]=$34;
2281       $1=1;
2282       __label__ = 11; break;
2283     case 6:
2284       var $38=$3;
2285       var $39=$2;
2286       var $40=(($39+56)|0);
2287       HEAP32[(($40)>>2)]=$38;
2288       var $41=$3;
2289       var $42=$2;
2290       var $43=(($42+60)|0);
2291       var $44=HEAP32[(($43)>>2)];
2292       var $45=Math.floor(((($44)>>>0))/(2));
2293       var $46=(($41)>>>0) < (($45)>>>0);
2294       if ($46) { __label__ = 7; break; } else { __label__ = 10; break; }
2295     case 7:
2296       var $48=$3;
2297       var $49=(($48)|0);
2298       var $50=_util_memory_a($49, 38, ((STRING_TABLE.__str)|0));
2299       $reall=$50;
2300       var $51=$reall;
2301       var $52=(($51)|0)!=0;
2302       if ($52) { __label__ = 9; break; } else { __label__ = 8; break; }
2303     case 8:
2304       $1=0;
2305       __label__ = 11; break;
2306     case 9:
2307       var $55=$reall;
2308       var $56=$2;
2309       var $57=(($56+52)|0);
2310       var $58=HEAP32[(($57)>>2)];
2311       var $59=$3;
2312       var $60=(($59)|0);
2313       assert($60 % 1 === 0, 'memcpy given ' + $60 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($55, $58, $60, 1);
2314       var $61=$2;
2315       var $62=(($61+52)|0);
2316       var $63=HEAP32[(($62)>>2)];
2317       _util_memory_d($63, 38, ((STRING_TABLE.__str)|0));
2318       var $64=$reall;
2319       var $65=$2;
2320       var $66=(($65+52)|0);
2321       HEAP32[(($66)>>2)]=$64;
2322       var $67=$3;
2323       var $68=$2;
2324       var $69=(($68+60)|0);
2325       HEAP32[(($69)>>2)]=$67;
2326       __label__ = 10; break;
2327     case 10:
2328       $1=1;
2329       __label__ = 11; break;
2330     case 11:
2331       var $72=$1;
2332       ;
2333       return $72;
2334     default: assert(0, "bad label: " + __label__);
2335   }
2336 }
2337 _qc_program_strings_resize["X"]=1;
2338
2339 function _qc_program_globals_remove($self, $idx) {
2340   ;
2341   var __label__;
2342   __label__ = 2;
2343   while(1) switch(__label__) {
2344     case 2:
2345       var $1;
2346       var $2;
2347       var $3;
2348       var $i;
2349       var $reall;
2350       $2=$self;
2351       $3=$idx;
2352       var $4=$3;
2353       var $5=$2;
2354       var $6=(($5+68)|0);
2355       var $7=HEAP32[(($6)>>2)];
2356       var $8=(($4)>>>0) >= (($7)>>>0);
2357       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2358     case 3:
2359       $1=1;
2360       __label__ = 13; break;
2361     case 4:
2362       var $11=$3;
2363       $i=$11;
2364       __label__ = 5; break;
2365     case 5:
2366       var $13=$i;
2367       var $14=$2;
2368       var $15=(($14+68)|0);
2369       var $16=HEAP32[(($15)>>2)];
2370       var $17=((($16)-(1))|0);
2371       var $18=(($13)>>>0) < (($17)>>>0);
2372       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2373     case 6:
2374       var $20=$i;
2375       var $21=((($20)+(1))|0);
2376       var $22=$2;
2377       var $23=(($22+64)|0);
2378       var $24=HEAP32[(($23)>>2)];
2379       var $25=(($24+($21<<2))|0);
2380       var $26=HEAP32[(($25)>>2)];
2381       var $27=$i;
2382       var $28=$2;
2383       var $29=(($28+64)|0);
2384       var $30=HEAP32[(($29)>>2)];
2385       var $31=(($30+($27<<2))|0);
2386       HEAP32[(($31)>>2)]=$26;
2387       __label__ = 7; break;
2388     case 7:
2389       var $33=$i;
2390       var $34=((($33)+(1))|0);
2391       $i=$34;
2392       __label__ = 5; break;
2393     case 8:
2394       var $36=$2;
2395       var $37=(($36+68)|0);
2396       var $38=HEAP32[(($37)>>2)];
2397       var $39=((($38)-(1))|0);
2398       HEAP32[(($37)>>2)]=$39;
2399       var $40=$2;
2400       var $41=(($40+68)|0);
2401       var $42=HEAP32[(($41)>>2)];
2402       var $43=$2;
2403       var $44=(($43+68)|0);
2404       var $45=HEAP32[(($44)>>2)];
2405       var $46=Math.floor(((($45)>>>0))/(2));
2406       var $47=(($42)>>>0) < (($46)>>>0);
2407       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
2408     case 9:
2409       var $49=$2;
2410       var $50=(($49+72)|0);
2411       var $51=HEAP32[(($50)>>2)];
2412       var $52=Math.floor(((($51)>>>0))/(2));
2413       HEAP32[(($50)>>2)]=$52;
2414       var $53=$2;
2415       var $54=(($53+68)|0);
2416       var $55=HEAP32[(($54)>>2)];
2417       var $56=((($55<<2))|0);
2418       var $57=_util_memory_a($56, 39, ((STRING_TABLE.__str)|0));
2419       var $58=$57;
2420       $reall=$58;
2421       var $59=$reall;
2422       var $60=(($59)|0)!=0;
2423       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
2424     case 10:
2425       $1=0;
2426       __label__ = 13; break;
2427     case 11:
2428       var $63=$reall;
2429       var $64=$63;
2430       var $65=$2;
2431       var $66=(($65+64)|0);
2432       var $67=HEAP32[(($66)>>2)];
2433       var $68=$67;
2434       var $69=$2;
2435       var $70=(($69+68)|0);
2436       var $71=HEAP32[(($70)>>2)];
2437       var $72=((($71<<2))|0);
2438       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
2439       var $73=$2;
2440       var $74=(($73+64)|0);
2441       var $75=HEAP32[(($74)>>2)];
2442       var $76=$75;
2443       _util_memory_d($76, 39, ((STRING_TABLE.__str)|0));
2444       var $77=$reall;
2445       var $78=$2;
2446       var $79=(($78+64)|0);
2447       HEAP32[(($79)>>2)]=$77;
2448       __label__ = 12; break;
2449     case 12:
2450       $1=1;
2451       __label__ = 13; break;
2452     case 13:
2453       var $82=$1;
2454       ;
2455       return $82;
2456     default: assert(0, "bad label: " + __label__);
2457   }
2458 }
2459 _qc_program_globals_remove["X"]=1;
2460
2461 function _qc_program_globals_add($self, $f) {
2462   ;
2463   var __label__;
2464   __label__ = 2;
2465   while(1) switch(__label__) {
2466     case 2:
2467       var $1;
2468       var $2;
2469       var $3;
2470       var $reall;
2471       $2=$self;
2472       $3=$f;
2473       var $4=$2;
2474       var $5=(($4+68)|0);
2475       var $6=HEAP32[(($5)>>2)];
2476       var $7=$2;
2477       var $8=(($7+72)|0);
2478       var $9=HEAP32[(($8)>>2)];
2479       var $10=(($6)|0)==(($9)|0);
2480       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
2481     case 3:
2482       var $12=$2;
2483       var $13=(($12+72)|0);
2484       var $14=HEAP32[(($13)>>2)];
2485       var $15=(($14)|0)!=0;
2486       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
2487     case 4:
2488       var $17=$2;
2489       var $18=(($17+72)|0);
2490       HEAP32[(($18)>>2)]=16;
2491       __label__ = 6; break;
2492     case 5:
2493       var $20=$2;
2494       var $21=(($20+72)|0);
2495       var $22=HEAP32[(($21)>>2)];
2496       var $23=((($22<<1))|0);
2497       HEAP32[(($21)>>2)]=$23;
2498       __label__ = 6; break;
2499     case 6:
2500       var $25=$2;
2501       var $26=(($25+72)|0);
2502       var $27=HEAP32[(($26)>>2)];
2503       var $28=((($27<<2))|0);
2504       var $29=_util_memory_a($28, 39, ((STRING_TABLE.__str)|0));
2505       var $30=$29;
2506       $reall=$30;
2507       var $31=$reall;
2508       var $32=(($31)|0)!=0;
2509       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2510     case 7:
2511       $1=0;
2512       __label__ = 10; break;
2513     case 8:
2514       var $35=$reall;
2515       var $36=$35;
2516       var $37=$2;
2517       var $38=(($37+64)|0);
2518       var $39=HEAP32[(($38)>>2)];
2519       var $40=$39;
2520       var $41=$2;
2521       var $42=(($41+68)|0);
2522       var $43=HEAP32[(($42)>>2)];
2523       var $44=((($43<<2))|0);
2524       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
2525       var $45=$2;
2526       var $46=(($45+64)|0);
2527       var $47=HEAP32[(($46)>>2)];
2528       var $48=$47;
2529       _util_memory_d($48, 39, ((STRING_TABLE.__str)|0));
2530       var $49=$reall;
2531       var $50=$2;
2532       var $51=(($50+64)|0);
2533       HEAP32[(($51)>>2)]=$49;
2534       __label__ = 9; break;
2535     case 9:
2536       var $53=$3;
2537       var $54=$2;
2538       var $55=(($54+68)|0);
2539       var $56=HEAP32[(($55)>>2)];
2540       var $57=((($56)+(1))|0);
2541       HEAP32[(($55)>>2)]=$57;
2542       var $58=$2;
2543       var $59=(($58+64)|0);
2544       var $60=HEAP32[(($59)>>2)];
2545       var $61=(($60+($56<<2))|0);
2546       HEAP32[(($61)>>2)]=$53;
2547       $1=1;
2548       __label__ = 10; break;
2549     case 10:
2550       var $63=$1;
2551       ;
2552       return $63;
2553     default: assert(0, "bad label: " + __label__);
2554   }
2555 }
2556 _qc_program_globals_add["X"]=1;
2557
2558 function _qc_program_entitydata_remove($self, $idx) {
2559   ;
2560   var __label__;
2561   __label__ = 2;
2562   while(1) switch(__label__) {
2563     case 2:
2564       var $1;
2565       var $2;
2566       var $3;
2567       var $i;
2568       var $reall;
2569       $2=$self;
2570       $3=$idx;
2571       var $4=$3;
2572       var $5=$2;
2573       var $6=(($5+80)|0);
2574       var $7=HEAP32[(($6)>>2)];
2575       var $8=(($4)>>>0) >= (($7)>>>0);
2576       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2577     case 3:
2578       $1=1;
2579       __label__ = 13; break;
2580     case 4:
2581       var $11=$3;
2582       $i=$11;
2583       __label__ = 5; break;
2584     case 5:
2585       var $13=$i;
2586       var $14=$2;
2587       var $15=(($14+80)|0);
2588       var $16=HEAP32[(($15)>>2)];
2589       var $17=((($16)-(1))|0);
2590       var $18=(($13)>>>0) < (($17)>>>0);
2591       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2592     case 6:
2593       var $20=$i;
2594       var $21=((($20)+(1))|0);
2595       var $22=$2;
2596       var $23=(($22+76)|0);
2597       var $24=HEAP32[(($23)>>2)];
2598       var $25=(($24+($21<<2))|0);
2599       var $26=HEAP32[(($25)>>2)];
2600       var $27=$i;
2601       var $28=$2;
2602       var $29=(($28+76)|0);
2603       var $30=HEAP32[(($29)>>2)];
2604       var $31=(($30+($27<<2))|0);
2605       HEAP32[(($31)>>2)]=$26;
2606       __label__ = 7; break;
2607     case 7:
2608       var $33=$i;
2609       var $34=((($33)+(1))|0);
2610       $i=$34;
2611       __label__ = 5; break;
2612     case 8:
2613       var $36=$2;
2614       var $37=(($36+80)|0);
2615       var $38=HEAP32[(($37)>>2)];
2616       var $39=((($38)-(1))|0);
2617       HEAP32[(($37)>>2)]=$39;
2618       var $40=$2;
2619       var $41=(($40+80)|0);
2620       var $42=HEAP32[(($41)>>2)];
2621       var $43=$2;
2622       var $44=(($43+80)|0);
2623       var $45=HEAP32[(($44)>>2)];
2624       var $46=Math.floor(((($45)>>>0))/(2));
2625       var $47=(($42)>>>0) < (($46)>>>0);
2626       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
2627     case 9:
2628       var $49=$2;
2629       var $50=(($49+84)|0);
2630       var $51=HEAP32[(($50)>>2)];
2631       var $52=Math.floor(((($51)>>>0))/(2));
2632       HEAP32[(($50)>>2)]=$52;
2633       var $53=$2;
2634       var $54=(($53+80)|0);
2635       var $55=HEAP32[(($54)>>2)];
2636       var $56=((($55<<2))|0);
2637       var $57=_util_memory_a($56, 40, ((STRING_TABLE.__str)|0));
2638       var $58=$57;
2639       $reall=$58;
2640       var $59=$reall;
2641       var $60=(($59)|0)!=0;
2642       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
2643     case 10:
2644       $1=0;
2645       __label__ = 13; break;
2646     case 11:
2647       var $63=$reall;
2648       var $64=$63;
2649       var $65=$2;
2650       var $66=(($65+76)|0);
2651       var $67=HEAP32[(($66)>>2)];
2652       var $68=$67;
2653       var $69=$2;
2654       var $70=(($69+80)|0);
2655       var $71=HEAP32[(($70)>>2)];
2656       var $72=((($71<<2))|0);
2657       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
2658       var $73=$2;
2659       var $74=(($73+76)|0);
2660       var $75=HEAP32[(($74)>>2)];
2661       var $76=$75;
2662       _util_memory_d($76, 40, ((STRING_TABLE.__str)|0));
2663       var $77=$reall;
2664       var $78=$2;
2665       var $79=(($78+76)|0);
2666       HEAP32[(($79)>>2)]=$77;
2667       __label__ = 12; break;
2668     case 12:
2669       $1=1;
2670       __label__ = 13; break;
2671     case 13:
2672       var $82=$1;
2673       ;
2674       return $82;
2675     default: assert(0, "bad label: " + __label__);
2676   }
2677 }
2678 _qc_program_entitydata_remove["X"]=1;
2679
2680 function _qc_program_entitydata_add($self, $f) {
2681   ;
2682   var __label__;
2683   __label__ = 2;
2684   while(1) switch(__label__) {
2685     case 2:
2686       var $1;
2687       var $2;
2688       var $3;
2689       var $reall;
2690       $2=$self;
2691       $3=$f;
2692       var $4=$2;
2693       var $5=(($4+80)|0);
2694       var $6=HEAP32[(($5)>>2)];
2695       var $7=$2;
2696       var $8=(($7+84)|0);
2697       var $9=HEAP32[(($8)>>2)];
2698       var $10=(($6)|0)==(($9)|0);
2699       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
2700     case 3:
2701       var $12=$2;
2702       var $13=(($12+84)|0);
2703       var $14=HEAP32[(($13)>>2)];
2704       var $15=(($14)|0)!=0;
2705       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
2706     case 4:
2707       var $17=$2;
2708       var $18=(($17+84)|0);
2709       HEAP32[(($18)>>2)]=16;
2710       __label__ = 6; break;
2711     case 5:
2712       var $20=$2;
2713       var $21=(($20+84)|0);
2714       var $22=HEAP32[(($21)>>2)];
2715       var $23=((($22<<1))|0);
2716       HEAP32[(($21)>>2)]=$23;
2717       __label__ = 6; break;
2718     case 6:
2719       var $25=$2;
2720       var $26=(($25+84)|0);
2721       var $27=HEAP32[(($26)>>2)];
2722       var $28=((($27<<2))|0);
2723       var $29=_util_memory_a($28, 40, ((STRING_TABLE.__str)|0));
2724       var $30=$29;
2725       $reall=$30;
2726       var $31=$reall;
2727       var $32=(($31)|0)!=0;
2728       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2729     case 7:
2730       $1=0;
2731       __label__ = 10; break;
2732     case 8:
2733       var $35=$reall;
2734       var $36=$35;
2735       var $37=$2;
2736       var $38=(($37+76)|0);
2737       var $39=HEAP32[(($38)>>2)];
2738       var $40=$39;
2739       var $41=$2;
2740       var $42=(($41+80)|0);
2741       var $43=HEAP32[(($42)>>2)];
2742       var $44=((($43<<2))|0);
2743       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
2744       var $45=$2;
2745       var $46=(($45+76)|0);
2746       var $47=HEAP32[(($46)>>2)];
2747       var $48=$47;
2748       _util_memory_d($48, 40, ((STRING_TABLE.__str)|0));
2749       var $49=$reall;
2750       var $50=$2;
2751       var $51=(($50+76)|0);
2752       HEAP32[(($51)>>2)]=$49;
2753       __label__ = 9; break;
2754     case 9:
2755       var $53=$3;
2756       var $54=$2;
2757       var $55=(($54+80)|0);
2758       var $56=HEAP32[(($55)>>2)];
2759       var $57=((($56)+(1))|0);
2760       HEAP32[(($55)>>2)]=$57;
2761       var $58=$2;
2762       var $59=(($58+76)|0);
2763       var $60=HEAP32[(($59)>>2)];
2764       var $61=(($60+($56<<2))|0);
2765       HEAP32[(($61)>>2)]=$53;
2766       $1=1;
2767       __label__ = 10; break;
2768     case 10:
2769       var $63=$1;
2770       ;
2771       return $63;
2772     default: assert(0, "bad label: " + __label__);
2773   }
2774 }
2775 _qc_program_entitydata_add["X"]=1;
2776
2777 function _qc_program_entitypool_remove($self, $idx) {
2778   ;
2779   var __label__;
2780   __label__ = 2;
2781   while(1) switch(__label__) {
2782     case 2:
2783       var $1;
2784       var $2;
2785       var $3;
2786       var $i;
2787       var $reall;
2788       $2=$self;
2789       $3=$idx;
2790       var $4=$3;
2791       var $5=$2;
2792       var $6=(($5+92)|0);
2793       var $7=HEAP32[(($6)>>2)];
2794       var $8=(($4)>>>0) >= (($7)>>>0);
2795       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
2796     case 3:
2797       $1=1;
2798       __label__ = 13; break;
2799     case 4:
2800       var $11=$3;
2801       $i=$11;
2802       __label__ = 5; break;
2803     case 5:
2804       var $13=$i;
2805       var $14=$2;
2806       var $15=(($14+92)|0);
2807       var $16=HEAP32[(($15)>>2)];
2808       var $17=((($16)-(1))|0);
2809       var $18=(($13)>>>0) < (($17)>>>0);
2810       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
2811     case 6:
2812       var $20=$i;
2813       var $21=((($20)+(1))|0);
2814       var $22=$2;
2815       var $23=(($22+88)|0);
2816       var $24=HEAP32[(($23)>>2)];
2817       var $25=(($24+$21)|0);
2818       var $26=HEAP8[($25)];
2819       var $27=(($26) & 1);
2820       var $28=$i;
2821       var $29=$2;
2822       var $30=(($29+88)|0);
2823       var $31=HEAP32[(($30)>>2)];
2824       var $32=(($31+$28)|0);
2825       var $33=(($27)&1);
2826       HEAP8[($32)]=$33;
2827       __label__ = 7; break;
2828     case 7:
2829       var $35=$i;
2830       var $36=((($35)+(1))|0);
2831       $i=$36;
2832       __label__ = 5; break;
2833     case 8:
2834       var $38=$2;
2835       var $39=(($38+92)|0);
2836       var $40=HEAP32[(($39)>>2)];
2837       var $41=((($40)-(1))|0);
2838       HEAP32[(($39)>>2)]=$41;
2839       var $42=$2;
2840       var $43=(($42+92)|0);
2841       var $44=HEAP32[(($43)>>2)];
2842       var $45=$2;
2843       var $46=(($45+92)|0);
2844       var $47=HEAP32[(($46)>>2)];
2845       var $48=Math.floor(((($47)>>>0))/(2));
2846       var $49=(($44)>>>0) < (($48)>>>0);
2847       if ($49) { __label__ = 9; break; } else { __label__ = 12; break; }
2848     case 9:
2849       var $51=$2;
2850       var $52=(($51+96)|0);
2851       var $53=HEAP32[(($52)>>2)];
2852       var $54=Math.floor(((($53)>>>0))/(2));
2853       HEAP32[(($52)>>2)]=$54;
2854       var $55=$2;
2855       var $56=(($55+92)|0);
2856       var $57=HEAP32[(($56)>>2)];
2857       var $58=(($57)|0);
2858       var $59=_util_memory_a($58, 41, ((STRING_TABLE.__str)|0));
2859       $reall=$59;
2860       var $60=$reall;
2861       var $61=(($60)|0)!=0;
2862       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
2863     case 10:
2864       $1=0;
2865       __label__ = 13; break;
2866     case 11:
2867       var $64=$reall;
2868       var $65=$2;
2869       var $66=(($65+88)|0);
2870       var $67=HEAP32[(($66)>>2)];
2871       var $68=$2;
2872       var $69=(($68+92)|0);
2873       var $70=HEAP32[(($69)>>2)];
2874       var $71=(($70)|0);
2875       assert($71 % 1 === 0, 'memcpy given ' + $71 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $67, $71, 1);
2876       var $72=$2;
2877       var $73=(($72+88)|0);
2878       var $74=HEAP32[(($73)>>2)];
2879       _util_memory_d($74, 41, ((STRING_TABLE.__str)|0));
2880       var $75=$reall;
2881       var $76=$2;
2882       var $77=(($76+88)|0);
2883       HEAP32[(($77)>>2)]=$75;
2884       __label__ = 12; break;
2885     case 12:
2886       $1=1;
2887       __label__ = 13; break;
2888     case 13:
2889       var $80=$1;
2890       ;
2891       return $80;
2892     default: assert(0, "bad label: " + __label__);
2893   }
2894 }
2895 _qc_program_entitypool_remove["X"]=1;
2896
2897 function _qc_program_entitypool_add($self, $f) {
2898   ;
2899   var __label__;
2900   __label__ = 2;
2901   while(1) switch(__label__) {
2902     case 2:
2903       var $1;
2904       var $2;
2905       var $3;
2906       var $reall;
2907       $2=$self;
2908       var $4=(($f)&1);
2909       $3=$4;
2910       var $5=$2;
2911       var $6=(($5+92)|0);
2912       var $7=HEAP32[(($6)>>2)];
2913       var $8=$2;
2914       var $9=(($8+96)|0);
2915       var $10=HEAP32[(($9)>>2)];
2916       var $11=(($7)|0)==(($10)|0);
2917       if ($11) { __label__ = 3; break; } else { __label__ = 9; break; }
2918     case 3:
2919       var $13=$2;
2920       var $14=(($13+96)|0);
2921       var $15=HEAP32[(($14)>>2)];
2922       var $16=(($15)|0)!=0;
2923       if ($16) { __label__ = 5; break; } else { __label__ = 4; break; }
2924     case 4:
2925       var $18=$2;
2926       var $19=(($18+96)|0);
2927       HEAP32[(($19)>>2)]=16;
2928       __label__ = 6; break;
2929     case 5:
2930       var $21=$2;
2931       var $22=(($21+96)|0);
2932       var $23=HEAP32[(($22)>>2)];
2933       var $24=((($23<<1))|0);
2934       HEAP32[(($22)>>2)]=$24;
2935       __label__ = 6; break;
2936     case 6:
2937       var $26=$2;
2938       var $27=(($26+96)|0);
2939       var $28=HEAP32[(($27)>>2)];
2940       var $29=(($28)|0);
2941       var $30=_util_memory_a($29, 41, ((STRING_TABLE.__str)|0));
2942       $reall=$30;
2943       var $31=$reall;
2944       var $32=(($31)|0)!=0;
2945       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
2946     case 7:
2947       $1=0;
2948       __label__ = 10; break;
2949     case 8:
2950       var $35=$reall;
2951       var $36=$2;
2952       var $37=(($36+88)|0);
2953       var $38=HEAP32[(($37)>>2)];
2954       var $39=$2;
2955       var $40=(($39+92)|0);
2956       var $41=HEAP32[(($40)>>2)];
2957       var $42=(($41)|0);
2958       assert($42 % 1 === 0, 'memcpy given ' + $42 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $38, $42, 1);
2959       var $43=$2;
2960       var $44=(($43+88)|0);
2961       var $45=HEAP32[(($44)>>2)];
2962       _util_memory_d($45, 41, ((STRING_TABLE.__str)|0));
2963       var $46=$reall;
2964       var $47=$2;
2965       var $48=(($47+88)|0);
2966       HEAP32[(($48)>>2)]=$46;
2967       __label__ = 9; break;
2968     case 9:
2969       var $50=$3;
2970       var $51=(($50) & 1);
2971       var $52=$2;
2972       var $53=(($52+92)|0);
2973       var $54=HEAP32[(($53)>>2)];
2974       var $55=((($54)+(1))|0);
2975       HEAP32[(($53)>>2)]=$55;
2976       var $56=$2;
2977       var $57=(($56+88)|0);
2978       var $58=HEAP32[(($57)>>2)];
2979       var $59=(($58+$54)|0);
2980       var $60=(($51)&1);
2981       HEAP8[($59)]=$60;
2982       $1=1;
2983       __label__ = 10; break;
2984     case 10:
2985       var $62=$1;
2986       ;
2987       return $62;
2988     default: assert(0, "bad label: " + __label__);
2989   }
2990 }
2991 _qc_program_entitypool_add["X"]=1;
2992
2993 function _qc_program_localstack_remove($self, $idx) {
2994   ;
2995   var __label__;
2996   __label__ = 2;
2997   while(1) switch(__label__) {
2998     case 2:
2999       var $1;
3000       var $2;
3001       var $3;
3002       var $i;
3003       var $reall;
3004       $2=$self;
3005       $3=$idx;
3006       var $4=$3;
3007       var $5=$2;
3008       var $6=(($5+156)|0);
3009       var $7=HEAP32[(($6)>>2)];
3010       var $8=(($4)>>>0) >= (($7)>>>0);
3011       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
3012     case 3:
3013       $1=1;
3014       __label__ = 13; break;
3015     case 4:
3016       var $11=$3;
3017       $i=$11;
3018       __label__ = 5; break;
3019     case 5:
3020       var $13=$i;
3021       var $14=$2;
3022       var $15=(($14+156)|0);
3023       var $16=HEAP32[(($15)>>2)];
3024       var $17=((($16)-(1))|0);
3025       var $18=(($13)>>>0) < (($17)>>>0);
3026       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3027     case 6:
3028       var $20=$i;
3029       var $21=((($20)+(1))|0);
3030       var $22=$2;
3031       var $23=(($22+152)|0);
3032       var $24=HEAP32[(($23)>>2)];
3033       var $25=(($24+($21<<2))|0);
3034       var $26=HEAP32[(($25)>>2)];
3035       var $27=$i;
3036       var $28=$2;
3037       var $29=(($28+152)|0);
3038       var $30=HEAP32[(($29)>>2)];
3039       var $31=(($30+($27<<2))|0);
3040       HEAP32[(($31)>>2)]=$26;
3041       __label__ = 7; break;
3042     case 7:
3043       var $33=$i;
3044       var $34=((($33)+(1))|0);
3045       $i=$34;
3046       __label__ = 5; break;
3047     case 8:
3048       var $36=$2;
3049       var $37=(($36+156)|0);
3050       var $38=HEAP32[(($37)>>2)];
3051       var $39=((($38)-(1))|0);
3052       HEAP32[(($37)>>2)]=$39;
3053       var $40=$2;
3054       var $41=(($40+156)|0);
3055       var $42=HEAP32[(($41)>>2)];
3056       var $43=$2;
3057       var $44=(($43+156)|0);
3058       var $45=HEAP32[(($44)>>2)];
3059       var $46=Math.floor(((($45)>>>0))/(2));
3060       var $47=(($42)>>>0) < (($46)>>>0);
3061       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
3062     case 9:
3063       var $49=$2;
3064       var $50=(($49+160)|0);
3065       var $51=HEAP32[(($50)>>2)];
3066       var $52=Math.floor(((($51)>>>0))/(2));
3067       HEAP32[(($50)>>2)]=$52;
3068       var $53=$2;
3069       var $54=(($53+156)|0);
3070       var $55=HEAP32[(($54)>>2)];
3071       var $56=((($55<<2))|0);
3072       var $57=_util_memory_a($56, 43, ((STRING_TABLE.__str)|0));
3073       var $58=$57;
3074       $reall=$58;
3075       var $59=$reall;
3076       var $60=(($59)|0)!=0;
3077       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
3078     case 10:
3079       $1=0;
3080       __label__ = 13; break;
3081     case 11:
3082       var $63=$reall;
3083       var $64=$63;
3084       var $65=$2;
3085       var $66=(($65+152)|0);
3086       var $67=HEAP32[(($66)>>2)];
3087       var $68=$67;
3088       var $69=$2;
3089       var $70=(($69+156)|0);
3090       var $71=HEAP32[(($70)>>2)];
3091       var $72=((($71<<2))|0);
3092       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
3093       var $73=$2;
3094       var $74=(($73+152)|0);
3095       var $75=HEAP32[(($74)>>2)];
3096       var $76=$75;
3097       _util_memory_d($76, 43, ((STRING_TABLE.__str)|0));
3098       var $77=$reall;
3099       var $78=$2;
3100       var $79=(($78+152)|0);
3101       HEAP32[(($79)>>2)]=$77;
3102       __label__ = 12; break;
3103     case 12:
3104       $1=1;
3105       __label__ = 13; break;
3106     case 13:
3107       var $82=$1;
3108       ;
3109       return $82;
3110     default: assert(0, "bad label: " + __label__);
3111   }
3112 }
3113 _qc_program_localstack_remove["X"]=1;
3114
3115 function _qc_program_localstack_add($self, $f) {
3116   ;
3117   var __label__;
3118   __label__ = 2;
3119   while(1) switch(__label__) {
3120     case 2:
3121       var $1;
3122       var $2;
3123       var $3;
3124       var $reall;
3125       $2=$self;
3126       $3=$f;
3127       var $4=$2;
3128       var $5=(($4+156)|0);
3129       var $6=HEAP32[(($5)>>2)];
3130       var $7=$2;
3131       var $8=(($7+160)|0);
3132       var $9=HEAP32[(($8)>>2)];
3133       var $10=(($6)|0)==(($9)|0);
3134       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
3135     case 3:
3136       var $12=$2;
3137       var $13=(($12+160)|0);
3138       var $14=HEAP32[(($13)>>2)];
3139       var $15=(($14)|0)!=0;
3140       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3141     case 4:
3142       var $17=$2;
3143       var $18=(($17+160)|0);
3144       HEAP32[(($18)>>2)]=16;
3145       __label__ = 6; break;
3146     case 5:
3147       var $20=$2;
3148       var $21=(($20+160)|0);
3149       var $22=HEAP32[(($21)>>2)];
3150       var $23=((($22<<1))|0);
3151       HEAP32[(($21)>>2)]=$23;
3152       __label__ = 6; break;
3153     case 6:
3154       var $25=$2;
3155       var $26=(($25+160)|0);
3156       var $27=HEAP32[(($26)>>2)];
3157       var $28=((($27<<2))|0);
3158       var $29=_util_memory_a($28, 43, ((STRING_TABLE.__str)|0));
3159       var $30=$29;
3160       $reall=$30;
3161       var $31=$reall;
3162       var $32=(($31)|0)!=0;
3163       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
3164     case 7:
3165       $1=0;
3166       __label__ = 10; break;
3167     case 8:
3168       var $35=$reall;
3169       var $36=$35;
3170       var $37=$2;
3171       var $38=(($37+152)|0);
3172       var $39=HEAP32[(($38)>>2)];
3173       var $40=$39;
3174       var $41=$2;
3175       var $42=(($41+156)|0);
3176       var $43=HEAP32[(($42)>>2)];
3177       var $44=((($43<<2))|0);
3178       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
3179       var $45=$2;
3180       var $46=(($45+152)|0);
3181       var $47=HEAP32[(($46)>>2)];
3182       var $48=$47;
3183       _util_memory_d($48, 43, ((STRING_TABLE.__str)|0));
3184       var $49=$reall;
3185       var $50=$2;
3186       var $51=(($50+152)|0);
3187       HEAP32[(($51)>>2)]=$49;
3188       __label__ = 9; break;
3189     case 9:
3190       var $53=$3;
3191       var $54=$2;
3192       var $55=(($54+156)|0);
3193       var $56=HEAP32[(($55)>>2)];
3194       var $57=((($56)+(1))|0);
3195       HEAP32[(($55)>>2)]=$57;
3196       var $58=$2;
3197       var $59=(($58+152)|0);
3198       var $60=HEAP32[(($59)>>2)];
3199       var $61=(($60+($56<<2))|0);
3200       HEAP32[(($61)>>2)]=$53;
3201       $1=1;
3202       __label__ = 10; break;
3203     case 10:
3204       var $63=$1;
3205       ;
3206       return $63;
3207     default: assert(0, "bad label: " + __label__);
3208   }
3209 }
3210 _qc_program_localstack_add["X"]=1;
3211
3212 function _qc_program_localstack_append($s, $p, $c) {
3213   ;
3214   var __label__;
3215   __label__ = 2;
3216   while(1) switch(__label__) {
3217     case 2:
3218       var $1;
3219       var $2;
3220       var $3;
3221       var $4;
3222       var $reall;
3223       var $oldalloc;
3224       $2=$s;
3225       $3=$p;
3226       $4=$c;
3227       var $5=$2;
3228       var $6=(($5+156)|0);
3229       var $7=HEAP32[(($6)>>2)];
3230       var $8=$4;
3231       var $9=((($7)+($8))|0);
3232       var $10=$2;
3233       var $11=(($10+160)|0);
3234       var $12=HEAP32[(($11)>>2)];
3235       var $13=(($9)>>>0) > (($12)>>>0);
3236       if ($13) { __label__ = 3; break; } else { __label__ = 14; break; }
3237     case 3:
3238       var $15=$2;
3239       var $16=(($15+160)|0);
3240       var $17=HEAP32[(($16)>>2)];
3241       var $18=(($17)|0)!=0;
3242       if ($18) { __label__ = 8; break; } else { __label__ = 4; break; }
3243     case 4:
3244       var $20=$4;
3245       var $21=(($20)>>>0) < 16;
3246       if ($21) { __label__ = 5; break; } else { __label__ = 6; break; }
3247     case 5:
3248       var $26 = 16;__label__ = 7; break;
3249     case 6:
3250       var $24=$4;
3251       var $26 = $24;__label__ = 7; break;
3252     case 7:
3253       var $26;
3254       var $27=$2;
3255       var $28=(($27+160)|0);
3256       HEAP32[(($28)>>2)]=$26;
3257       var $29=$2;
3258       var $30=(($29+160)|0);
3259       var $31=HEAP32[(($30)>>2)];
3260       var $32=((($31<<2))|0);
3261       var $33=_util_memory_a($32, 44, ((STRING_TABLE.__str)|0));
3262       var $34=$33;
3263       var $35=$2;
3264       var $36=(($35+152)|0);
3265       HEAP32[(($36)>>2)]=$34;
3266       __label__ = 13; break;
3267     case 8:
3268       var $38=$2;
3269       var $39=(($38+160)|0);
3270       var $40=HEAP32[(($39)>>2)];
3271       $oldalloc=$40;
3272       var $41=$2;
3273       var $42=(($41+160)|0);
3274       var $43=HEAP32[(($42)>>2)];
3275       var $44=((($43<<1))|0);
3276       HEAP32[(($42)>>2)]=$44;
3277       var $45=$2;
3278       var $46=(($45+156)|0);
3279       var $47=HEAP32[(($46)>>2)];
3280       var $48=$4;
3281       var $49=((($47)+($48))|0);
3282       var $50=$2;
3283       var $51=(($50+160)|0);
3284       var $52=HEAP32[(($51)>>2)];
3285       var $53=(($49)>>>0) >= (($52)>>>0);
3286       if ($53) { __label__ = 9; break; } else { __label__ = 10; break; }
3287     case 9:
3288       var $55=$2;
3289       var $56=(($55+156)|0);
3290       var $57=HEAP32[(($56)>>2)];
3291       var $58=$4;
3292       var $59=((($57)+($58))|0);
3293       var $60=$2;
3294       var $61=(($60+160)|0);
3295       HEAP32[(($61)>>2)]=$59;
3296       __label__ = 10; break;
3297     case 10:
3298       var $63=$2;
3299       var $64=(($63+160)|0);
3300       var $65=HEAP32[(($64)>>2)];
3301       var $66=((($65<<2))|0);
3302       var $67=_util_memory_a($66, 44, ((STRING_TABLE.__str)|0));
3303       var $68=$67;
3304       $reall=$68;
3305       var $69=$reall;
3306       var $70=(($69)|0)!=0;
3307       if ($70) { __label__ = 12; break; } else { __label__ = 11; break; }
3308     case 11:
3309       var $72=$oldalloc;
3310       var $73=$2;
3311       var $74=(($73+160)|0);
3312       HEAP32[(($74)>>2)]=$72;
3313       $1=0;
3314       __label__ = 15; break;
3315     case 12:
3316       var $76=$reall;
3317       var $77=$76;
3318       var $78=$2;
3319       var $79=(($78+152)|0);
3320       var $80=HEAP32[(($79)>>2)];
3321       var $81=$80;
3322       var $82=$2;
3323       var $83=(($82+156)|0);
3324       var $84=HEAP32[(($83)>>2)];
3325       var $85=((($84<<2))|0);
3326       assert($85 % 1 === 0, 'memcpy given ' + $85 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($77, $81, $85, 4);
3327       var $86=$2;
3328       var $87=(($86+152)|0);
3329       var $88=HEAP32[(($87)>>2)];
3330       var $89=$88;
3331       _util_memory_d($89, 44, ((STRING_TABLE.__str)|0));
3332       var $90=$reall;
3333       var $91=$2;
3334       var $92=(($91+152)|0);
3335       HEAP32[(($92)>>2)]=$90;
3336       __label__ = 13; break;
3337     case 13:
3338       __label__ = 14; break;
3339     case 14:
3340       var $95=$2;
3341       var $96=(($95+156)|0);
3342       var $97=HEAP32[(($96)>>2)];
3343       var $98=$2;
3344       var $99=(($98+152)|0);
3345       var $100=HEAP32[(($99)>>2)];
3346       var $101=(($100+($97<<2))|0);
3347       var $102=$101;
3348       var $103=$3;
3349       var $104=$103;
3350       var $105=$4;
3351       var $106=((($105<<2))|0);
3352       assert($106 % 1 === 0, 'memcpy given ' + $106 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($102, $104, $106, 4);
3353       var $107=$4;
3354       var $108=$2;
3355       var $109=(($108+156)|0);
3356       var $110=HEAP32[(($109)>>2)];
3357       var $111=((($110)+($107))|0);
3358       HEAP32[(($109)>>2)]=$111;
3359       $1=1;
3360       __label__ = 15; break;
3361     case 15:
3362       var $113=$1;
3363       ;
3364       return $113;
3365     default: assert(0, "bad label: " + __label__);
3366   }
3367 }
3368 _qc_program_localstack_append["X"]=1;
3369
3370 function _qc_program_localstack_resize($s, $c) {
3371   ;
3372   var __label__;
3373   __label__ = 2;
3374   while(1) switch(__label__) {
3375     case 2:
3376       var $1;
3377       var $2;
3378       var $3;
3379       var $reall;
3380       $2=$s;
3381       $3=$c;
3382       var $4=$3;
3383       var $5=$2;
3384       var $6=(($5+160)|0);
3385       var $7=HEAP32[(($6)>>2)];
3386       var $8=(($4)>>>0) > (($7)>>>0);
3387       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
3388     case 3:
3389       var $10=$3;
3390       var $11=((($10<<2))|0);
3391       var $12=_util_memory_a($11, 45, ((STRING_TABLE.__str)|0));
3392       var $13=$12;
3393       $reall=$13;
3394       var $14=$reall;
3395       var $15=(($14)|0)!=0;
3396       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3397     case 4:
3398       $1=0;
3399       __label__ = 11; break;
3400     case 5:
3401       var $18=$reall;
3402       var $19=$18;
3403       var $20=$2;
3404       var $21=(($20+152)|0);
3405       var $22=HEAP32[(($21)>>2)];
3406       var $23=$22;
3407       var $24=$2;
3408       var $25=(($24+156)|0);
3409       var $26=HEAP32[(($25)>>2)];
3410       var $27=((($26<<2))|0);
3411       assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4);
3412       var $28=$3;
3413       var $29=$2;
3414       var $30=(($29+160)|0);
3415       HEAP32[(($30)>>2)]=$28;
3416       var $31=$3;
3417       var $32=$2;
3418       var $33=(($32+156)|0);
3419       HEAP32[(($33)>>2)]=$31;
3420       var $34=$2;
3421       var $35=(($34+152)|0);
3422       var $36=HEAP32[(($35)>>2)];
3423       var $37=$36;
3424       _util_memory_d($37, 45, ((STRING_TABLE.__str)|0));
3425       var $38=$reall;
3426       var $39=$2;
3427       var $40=(($39+152)|0);
3428       HEAP32[(($40)>>2)]=$38;
3429       $1=1;
3430       __label__ = 11; break;
3431     case 6:
3432       var $42=$3;
3433       var $43=$2;
3434       var $44=(($43+156)|0);
3435       HEAP32[(($44)>>2)]=$42;
3436       var $45=$3;
3437       var $46=$2;
3438       var $47=(($46+160)|0);
3439       var $48=HEAP32[(($47)>>2)];
3440       var $49=Math.floor(((($48)>>>0))/(2));
3441       var $50=(($45)>>>0) < (($49)>>>0);
3442       if ($50) { __label__ = 7; break; } else { __label__ = 10; break; }
3443     case 7:
3444       var $52=$3;
3445       var $53=((($52<<2))|0);
3446       var $54=_util_memory_a($53, 45, ((STRING_TABLE.__str)|0));
3447       var $55=$54;
3448       $reall=$55;
3449       var $56=$reall;
3450       var $57=(($56)|0)!=0;
3451       if ($57) { __label__ = 9; break; } else { __label__ = 8; break; }
3452     case 8:
3453       $1=0;
3454       __label__ = 11; break;
3455     case 9:
3456       var $60=$reall;
3457       var $61=$60;
3458       var $62=$2;
3459       var $63=(($62+152)|0);
3460       var $64=HEAP32[(($63)>>2)];
3461       var $65=$64;
3462       var $66=$3;
3463       var $67=((($66<<2))|0);
3464       assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4);
3465       var $68=$2;
3466       var $69=(($68+152)|0);
3467       var $70=HEAP32[(($69)>>2)];
3468       var $71=$70;
3469       _util_memory_d($71, 45, ((STRING_TABLE.__str)|0));
3470       var $72=$reall;
3471       var $73=$2;
3472       var $74=(($73+152)|0);
3473       HEAP32[(($74)>>2)]=$72;
3474       var $75=$3;
3475       var $76=$2;
3476       var $77=(($76+160)|0);
3477       HEAP32[(($77)>>2)]=$75;
3478       __label__ = 10; break;
3479     case 10:
3480       $1=1;
3481       __label__ = 11; break;
3482     case 11:
3483       var $80=$1;
3484       ;
3485       return $80;
3486     default: assert(0, "bad label: " + __label__);
3487   }
3488 }
3489 _qc_program_localstack_resize["X"]=1;
3490
3491 function _qc_program_stack_remove($self, $idx) {
3492   ;
3493   var __label__;
3494   __label__ = 2;
3495   while(1) switch(__label__) {
3496     case 2:
3497       var $1;
3498       var $2;
3499       var $3;
3500       var $i;
3501       var $reall;
3502       $2=$self;
3503       $3=$idx;
3504       var $4=$3;
3505       var $5=$2;
3506       var $6=(($5+168)|0);
3507       var $7=HEAP32[(($6)>>2)];
3508       var $8=(($4)>>>0) >= (($7)>>>0);
3509       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
3510     case 3:
3511       $1=1;
3512       __label__ = 13; break;
3513     case 4:
3514       var $11=$3;
3515       $i=$11;
3516       __label__ = 5; break;
3517     case 5:
3518       var $13=$i;
3519       var $14=$2;
3520       var $15=(($14+168)|0);
3521       var $16=HEAP32[(($15)>>2)];
3522       var $17=((($16)-(1))|0);
3523       var $18=(($13)>>>0) < (($17)>>>0);
3524       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3525     case 6:
3526       var $20=$i;
3527       var $21=$2;
3528       var $22=(($21+164)|0);
3529       var $23=HEAP32[(($22)>>2)];
3530       var $24=(($23+($20)*(12))|0);
3531       var $25=$i;
3532       var $26=((($25)+(1))|0);
3533       var $27=$2;
3534       var $28=(($27+164)|0);
3535       var $29=HEAP32[(($28)>>2)];
3536       var $30=(($29+($26)*(12))|0);
3537       var $31=$24;
3538       var $32=$30;
3539       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)];
3540       __label__ = 7; break;
3541     case 7:
3542       var $34=$i;
3543       var $35=((($34)+(1))|0);
3544       $i=$35;
3545       __label__ = 5; break;
3546     case 8:
3547       var $37=$2;
3548       var $38=(($37+168)|0);
3549       var $39=HEAP32[(($38)>>2)];
3550       var $40=((($39)-(1))|0);
3551       HEAP32[(($38)>>2)]=$40;
3552       var $41=$2;
3553       var $42=(($41+168)|0);
3554       var $43=HEAP32[(($42)>>2)];
3555       var $44=$2;
3556       var $45=(($44+168)|0);
3557       var $46=HEAP32[(($45)>>2)];
3558       var $47=Math.floor(((($46)>>>0))/(2));
3559       var $48=(($43)>>>0) < (($47)>>>0);
3560       if ($48) { __label__ = 9; break; } else { __label__ = 12; break; }
3561     case 9:
3562       var $50=$2;
3563       var $51=(($50+172)|0);
3564       var $52=HEAP32[(($51)>>2)];
3565       var $53=Math.floor(((($52)>>>0))/(2));
3566       HEAP32[(($51)>>2)]=$53;
3567       var $54=$2;
3568       var $55=(($54+168)|0);
3569       var $56=HEAP32[(($55)>>2)];
3570       var $57=((($56)*(12))|0);
3571       var $58=_util_memory_a($57, 46, ((STRING_TABLE.__str)|0));
3572       var $59=$58;
3573       $reall=$59;
3574       var $60=$reall;
3575       var $61=(($60)|0)!=0;
3576       if ($61) { __label__ = 11; break; } else { __label__ = 10; break; }
3577     case 10:
3578       $1=0;
3579       __label__ = 13; break;
3580     case 11:
3581       var $64=$reall;
3582       var $65=$64;
3583       var $66=$2;
3584       var $67=(($66+164)|0);
3585       var $68=HEAP32[(($67)>>2)];
3586       var $69=$68;
3587       var $70=$2;
3588       var $71=(($70+168)|0);
3589       var $72=HEAP32[(($71)>>2)];
3590       var $73=((($72)*(12))|0);
3591       assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4);
3592       var $74=$2;
3593       var $75=(($74+164)|0);
3594       var $76=HEAP32[(($75)>>2)];
3595       var $77=$76;
3596       _util_memory_d($77, 46, ((STRING_TABLE.__str)|0));
3597       var $78=$reall;
3598       var $79=$2;
3599       var $80=(($79+164)|0);
3600       HEAP32[(($80)>>2)]=$78;
3601       __label__ = 12; break;
3602     case 12:
3603       $1=1;
3604       __label__ = 13; break;
3605     case 13:
3606       var $83=$1;
3607       ;
3608       return $83;
3609     default: assert(0, "bad label: " + __label__);
3610   }
3611 }
3612 _qc_program_stack_remove["X"]=1;
3613
3614 function _qc_program_stack_add($self, $f_0, $f_1, $f_2) {
3615   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
3616   var __label__;
3617   __label__ = 2;
3618   while(1) switch(__label__) {
3619     case 2:
3620       var $1;
3621       var $2;
3622       var $f=__stackBase__;
3623       var $reall;
3624       $2=$self;
3625       var $3=(($f)|0);
3626       HEAP32[(($3)>>2)]=$f_0;
3627       var $4=(($f+4)|0);
3628       HEAP32[(($4)>>2)]=$f_1;
3629       var $5=(($f+8)|0);
3630       HEAP32[(($5)>>2)]=$f_2;
3631       var $6=$2;
3632       var $7=(($6+168)|0);
3633       var $8=HEAP32[(($7)>>2)];
3634       var $9=$2;
3635       var $10=(($9+172)|0);
3636       var $11=HEAP32[(($10)>>2)];
3637       var $12=(($8)|0)==(($11)|0);
3638       if ($12) { __label__ = 3; break; } else { __label__ = 9; break; }
3639     case 3:
3640       var $14=$2;
3641       var $15=(($14+172)|0);
3642       var $16=HEAP32[(($15)>>2)];
3643       var $17=(($16)|0)!=0;
3644       if ($17) { __label__ = 5; break; } else { __label__ = 4; break; }
3645     case 4:
3646       var $19=$2;
3647       var $20=(($19+172)|0);
3648       HEAP32[(($20)>>2)]=16;
3649       __label__ = 6; break;
3650     case 5:
3651       var $22=$2;
3652       var $23=(($22+172)|0);
3653       var $24=HEAP32[(($23)>>2)];
3654       var $25=((($24<<1))|0);
3655       HEAP32[(($23)>>2)]=$25;
3656       __label__ = 6; break;
3657     case 6:
3658       var $27=$2;
3659       var $28=(($27+172)|0);
3660       var $29=HEAP32[(($28)>>2)];
3661       var $30=((($29)*(12))|0);
3662       var $31=_util_memory_a($30, 46, ((STRING_TABLE.__str)|0));
3663       var $32=$31;
3664       $reall=$32;
3665       var $33=$reall;
3666       var $34=(($33)|0)!=0;
3667       if ($34) { __label__ = 8; break; } else { __label__ = 7; break; }
3668     case 7:
3669       $1=0;
3670       __label__ = 10; break;
3671     case 8:
3672       var $37=$reall;
3673       var $38=$37;
3674       var $39=$2;
3675       var $40=(($39+164)|0);
3676       var $41=HEAP32[(($40)>>2)];
3677       var $42=$41;
3678       var $43=$2;
3679       var $44=(($43+168)|0);
3680       var $45=HEAP32[(($44)>>2)];
3681       var $46=((($45)*(12))|0);
3682       assert($46 % 1 === 0, 'memcpy given ' + $46 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($38, $42, $46, 4);
3683       var $47=$2;
3684       var $48=(($47+164)|0);
3685       var $49=HEAP32[(($48)>>2)];
3686       var $50=$49;
3687       _util_memory_d($50, 46, ((STRING_TABLE.__str)|0));
3688       var $51=$reall;
3689       var $52=$2;
3690       var $53=(($52+164)|0);
3691       HEAP32[(($53)>>2)]=$51;
3692       __label__ = 9; break;
3693     case 9:
3694       var $55=$2;
3695       var $56=(($55+168)|0);
3696       var $57=HEAP32[(($56)>>2)];
3697       var $58=((($57)+(1))|0);
3698       HEAP32[(($56)>>2)]=$58;
3699       var $59=$2;
3700       var $60=(($59+164)|0);
3701       var $61=HEAP32[(($60)>>2)];
3702       var $62=(($61+($57)*(12))|0);
3703       var $63=$62;
3704       var $64=$f;
3705       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)];
3706       $1=1;
3707       __label__ = 10; break;
3708     case 10:
3709       var $66=$1;
3710       STACKTOP = __stackBase__;
3711       return $66;
3712     default: assert(0, "bad label: " + __label__);
3713   }
3714 }
3715 _qc_program_stack_add["X"]=1;
3716
3717 function _qc_program_profile_remove($self, $idx) {
3718   ;
3719   var __label__;
3720   __label__ = 2;
3721   while(1) switch(__label__) {
3722     case 2:
3723       var $1;
3724       var $2;
3725       var $3;
3726       var $i;
3727       var $reall;
3728       $2=$self;
3729       $3=$idx;
3730       var $4=$3;
3731       var $5=$2;
3732       var $6=(($5+120)|0);
3733       var $7=HEAP32[(($6)>>2)];
3734       var $8=(($4)>>>0) >= (($7)>>>0);
3735       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
3736     case 3:
3737       $1=1;
3738       __label__ = 13; break;
3739     case 4:
3740       var $11=$3;
3741       $i=$11;
3742       __label__ = 5; break;
3743     case 5:
3744       var $13=$i;
3745       var $14=$2;
3746       var $15=(($14+120)|0);
3747       var $16=HEAP32[(($15)>>2)];
3748       var $17=((($16)-(1))|0);
3749       var $18=(($13)>>>0) < (($17)>>>0);
3750       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
3751     case 6:
3752       var $20=$i;
3753       var $21=((($20)+(1))|0);
3754       var $22=$2;
3755       var $23=(($22+116)|0);
3756       var $24=HEAP32[(($23)>>2)];
3757       var $25=(($24+($21<<2))|0);
3758       var $26=HEAP32[(($25)>>2)];
3759       var $27=$i;
3760       var $28=$2;
3761       var $29=(($28+116)|0);
3762       var $30=HEAP32[(($29)>>2)];
3763       var $31=(($30+($27<<2))|0);
3764       HEAP32[(($31)>>2)]=$26;
3765       __label__ = 7; break;
3766     case 7:
3767       var $33=$i;
3768       var $34=((($33)+(1))|0);
3769       $i=$34;
3770       __label__ = 5; break;
3771     case 8:
3772       var $36=$2;
3773       var $37=(($36+120)|0);
3774       var $38=HEAP32[(($37)>>2)];
3775       var $39=((($38)-(1))|0);
3776       HEAP32[(($37)>>2)]=$39;
3777       var $40=$2;
3778       var $41=(($40+120)|0);
3779       var $42=HEAP32[(($41)>>2)];
3780       var $43=$2;
3781       var $44=(($43+120)|0);
3782       var $45=HEAP32[(($44)>>2)];
3783       var $46=Math.floor(((($45)>>>0))/(2));
3784       var $47=(($42)>>>0) < (($46)>>>0);
3785       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
3786     case 9:
3787       var $49=$2;
3788       var $50=(($49+124)|0);
3789       var $51=HEAP32[(($50)>>2)];
3790       var $52=Math.floor(((($51)>>>0))/(2));
3791       HEAP32[(($50)>>2)]=$52;
3792       var $53=$2;
3793       var $54=(($53+120)|0);
3794       var $55=HEAP32[(($54)>>2)];
3795       var $56=((($55<<2))|0);
3796       var $57=_util_memory_a($56, 48, ((STRING_TABLE.__str)|0));
3797       var $58=$57;
3798       $reall=$58;
3799       var $59=$reall;
3800       var $60=(($59)|0)!=0;
3801       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
3802     case 10:
3803       $1=0;
3804       __label__ = 13; break;
3805     case 11:
3806       var $63=$reall;
3807       var $64=$63;
3808       var $65=$2;
3809       var $66=(($65+116)|0);
3810       var $67=HEAP32[(($66)>>2)];
3811       var $68=$67;
3812       var $69=$2;
3813       var $70=(($69+120)|0);
3814       var $71=HEAP32[(($70)>>2)];
3815       var $72=((($71<<2))|0);
3816       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
3817       var $73=$2;
3818       var $74=(($73+116)|0);
3819       var $75=HEAP32[(($74)>>2)];
3820       var $76=$75;
3821       _util_memory_d($76, 48, ((STRING_TABLE.__str)|0));
3822       var $77=$reall;
3823       var $78=$2;
3824       var $79=(($78+116)|0);
3825       HEAP32[(($79)>>2)]=$77;
3826       __label__ = 12; break;
3827     case 12:
3828       $1=1;
3829       __label__ = 13; break;
3830     case 13:
3831       var $82=$1;
3832       ;
3833       return $82;
3834     default: assert(0, "bad label: " + __label__);
3835   }
3836 }
3837 _qc_program_profile_remove["X"]=1;
3838
3839 function _qc_program_profile_add($self, $f) {
3840   ;
3841   var __label__;
3842   __label__ = 2;
3843   while(1) switch(__label__) {
3844     case 2:
3845       var $1;
3846       var $2;
3847       var $3;
3848       var $reall;
3849       $2=$self;
3850       $3=$f;
3851       var $4=$2;
3852       var $5=(($4+120)|0);
3853       var $6=HEAP32[(($5)>>2)];
3854       var $7=$2;
3855       var $8=(($7+124)|0);
3856       var $9=HEAP32[(($8)>>2)];
3857       var $10=(($6)|0)==(($9)|0);
3858       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
3859     case 3:
3860       var $12=$2;
3861       var $13=(($12+124)|0);
3862       var $14=HEAP32[(($13)>>2)];
3863       var $15=(($14)|0)!=0;
3864       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3865     case 4:
3866       var $17=$2;
3867       var $18=(($17+124)|0);
3868       HEAP32[(($18)>>2)]=16;
3869       __label__ = 6; break;
3870     case 5:
3871       var $20=$2;
3872       var $21=(($20+124)|0);
3873       var $22=HEAP32[(($21)>>2)];
3874       var $23=((($22<<1))|0);
3875       HEAP32[(($21)>>2)]=$23;
3876       __label__ = 6; break;
3877     case 6:
3878       var $25=$2;
3879       var $26=(($25+124)|0);
3880       var $27=HEAP32[(($26)>>2)];
3881       var $28=((($27<<2))|0);
3882       var $29=_util_memory_a($28, 48, ((STRING_TABLE.__str)|0));
3883       var $30=$29;
3884       $reall=$30;
3885       var $31=$reall;
3886       var $32=(($31)|0)!=0;
3887       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
3888     case 7:
3889       $1=0;
3890       __label__ = 10; break;
3891     case 8:
3892       var $35=$reall;
3893       var $36=$35;
3894       var $37=$2;
3895       var $38=(($37+116)|0);
3896       var $39=HEAP32[(($38)>>2)];
3897       var $40=$39;
3898       var $41=$2;
3899       var $42=(($41+120)|0);
3900       var $43=HEAP32[(($42)>>2)];
3901       var $44=((($43<<2))|0);
3902       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
3903       var $45=$2;
3904       var $46=(($45+116)|0);
3905       var $47=HEAP32[(($46)>>2)];
3906       var $48=$47;
3907       _util_memory_d($48, 48, ((STRING_TABLE.__str)|0));
3908       var $49=$reall;
3909       var $50=$2;
3910       var $51=(($50+116)|0);
3911       HEAP32[(($51)>>2)]=$49;
3912       __label__ = 9; break;
3913     case 9:
3914       var $53=$3;
3915       var $54=$2;
3916       var $55=(($54+120)|0);
3917       var $56=HEAP32[(($55)>>2)];
3918       var $57=((($56)+(1))|0);
3919       HEAP32[(($55)>>2)]=$57;
3920       var $58=$2;
3921       var $59=(($58+116)|0);
3922       var $60=HEAP32[(($59)>>2)];
3923       var $61=(($60+($56<<2))|0);
3924       HEAP32[(($61)>>2)]=$53;
3925       $1=1;
3926       __label__ = 10; break;
3927     case 10:
3928       var $63=$1;
3929       ;
3930       return $63;
3931     default: assert(0, "bad label: " + __label__);
3932   }
3933 }
3934 _qc_program_profile_add["X"]=1;
3935
3936 function _qc_program_profile_resize($s, $c) {
3937   ;
3938   var __label__;
3939   __label__ = 2;
3940   while(1) switch(__label__) {
3941     case 2:
3942       var $1;
3943       var $2;
3944       var $3;
3945       var $reall;
3946       $2=$s;
3947       $3=$c;
3948       var $4=$3;
3949       var $5=$2;
3950       var $6=(($5+124)|0);
3951       var $7=HEAP32[(($6)>>2)];
3952       var $8=(($4)>>>0) > (($7)>>>0);
3953       if ($8) { __label__ = 3; break; } else { __label__ = 6; break; }
3954     case 3:
3955       var $10=$3;
3956       var $11=((($10<<2))|0);
3957       var $12=_util_memory_a($11, 49, ((STRING_TABLE.__str)|0));
3958       var $13=$12;
3959       $reall=$13;
3960       var $14=$reall;
3961       var $15=(($14)|0)!=0;
3962       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
3963     case 4:
3964       $1=0;
3965       __label__ = 11; break;
3966     case 5:
3967       var $18=$reall;
3968       var $19=$18;
3969       var $20=$2;
3970       var $21=(($20+116)|0);
3971       var $22=HEAP32[(($21)>>2)];
3972       var $23=$22;
3973       var $24=$2;
3974       var $25=(($24+120)|0);
3975       var $26=HEAP32[(($25)>>2)];
3976       var $27=((($26<<2))|0);
3977       assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4);
3978       var $28=$3;
3979       var $29=$2;
3980       var $30=(($29+124)|0);
3981       HEAP32[(($30)>>2)]=$28;
3982       var $31=$3;
3983       var $32=$2;
3984       var $33=(($32+120)|0);
3985       HEAP32[(($33)>>2)]=$31;
3986       var $34=$2;
3987       var $35=(($34+116)|0);
3988       var $36=HEAP32[(($35)>>2)];
3989       var $37=$36;
3990       _util_memory_d($37, 49, ((STRING_TABLE.__str)|0));
3991       var $38=$reall;
3992       var $39=$2;
3993       var $40=(($39+116)|0);
3994       HEAP32[(($40)>>2)]=$38;
3995       $1=1;
3996       __label__ = 11; break;
3997     case 6:
3998       var $42=$3;
3999       var $43=$2;
4000       var $44=(($43+120)|0);
4001       HEAP32[(($44)>>2)]=$42;
4002       var $45=$3;
4003       var $46=$2;
4004       var $47=(($46+124)|0);
4005       var $48=HEAP32[(($47)>>2)];
4006       var $49=Math.floor(((($48)>>>0))/(2));
4007       var $50=(($45)>>>0) < (($49)>>>0);
4008       if ($50) { __label__ = 7; break; } else { __label__ = 10; break; }
4009     case 7:
4010       var $52=$3;
4011       var $53=((($52<<2))|0);
4012       var $54=_util_memory_a($53, 49, ((STRING_TABLE.__str)|0));
4013       var $55=$54;
4014       $reall=$55;
4015       var $56=$reall;
4016       var $57=(($56)|0)!=0;
4017       if ($57) { __label__ = 9; break; } else { __label__ = 8; break; }
4018     case 8:
4019       $1=0;
4020       __label__ = 11; break;
4021     case 9:
4022       var $60=$reall;
4023       var $61=$60;
4024       var $62=$2;
4025       var $63=(($62+116)|0);
4026       var $64=HEAP32[(($63)>>2)];
4027       var $65=$64;
4028       var $66=$3;
4029       var $67=((($66<<2))|0);
4030       assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4);
4031       var $68=$2;
4032       var $69=(($68+116)|0);
4033       var $70=HEAP32[(($69)>>2)];
4034       var $71=$70;
4035       _util_memory_d($71, 49, ((STRING_TABLE.__str)|0));
4036       var $72=$reall;
4037       var $73=$2;
4038       var $74=(($73+116)|0);
4039       HEAP32[(($74)>>2)]=$72;
4040       var $75=$3;
4041       var $76=$2;
4042       var $77=(($76+124)|0);
4043       HEAP32[(($77)>>2)]=$75;
4044       __label__ = 10; break;
4045     case 10:
4046       $1=1;
4047       __label__ = 11; break;
4048     case 11:
4049       var $80=$1;
4050       ;
4051       return $80;
4052     default: assert(0, "bad label: " + __label__);
4053   }
4054 }
4055 _qc_program_profile_resize["X"]=1;
4056
4057 function _qc_program_builtins_remove($self, $idx) {
4058   ;
4059   var __label__;
4060   __label__ = 2;
4061   while(1) switch(__label__) {
4062     case 2:
4063       var $1;
4064       var $2;
4065       var $3;
4066       var $i;
4067       var $reall;
4068       $2=$self;
4069       $3=$idx;
4070       var $4=$3;
4071       var $5=$2;
4072       var $6=(($5+132)|0);
4073       var $7=HEAP32[(($6)>>2)];
4074       var $8=(($4)>>>0) >= (($7)>>>0);
4075       if ($8) { __label__ = 3; break; } else { __label__ = 4; break; }
4076     case 3:
4077       $1=1;
4078       __label__ = 13; break;
4079     case 4:
4080       var $11=$3;
4081       $i=$11;
4082       __label__ = 5; break;
4083     case 5:
4084       var $13=$i;
4085       var $14=$2;
4086       var $15=(($14+132)|0);
4087       var $16=HEAP32[(($15)>>2)];
4088       var $17=((($16)-(1))|0);
4089       var $18=(($13)>>>0) < (($17)>>>0);
4090       if ($18) { __label__ = 6; break; } else { __label__ = 8; break; }
4091     case 6:
4092       var $20=$i;
4093       var $21=((($20)+(1))|0);
4094       var $22=$2;
4095       var $23=(($22+128)|0);
4096       var $24=HEAP32[(($23)>>2)];
4097       var $25=(($24+($21<<2))|0);
4098       var $26=HEAP32[(($25)>>2)];
4099       var $27=$i;
4100       var $28=$2;
4101       var $29=(($28+128)|0);
4102       var $30=HEAP32[(($29)>>2)];
4103       var $31=(($30+($27<<2))|0);
4104       HEAP32[(($31)>>2)]=$26;
4105       __label__ = 7; break;
4106     case 7:
4107       var $33=$i;
4108       var $34=((($33)+(1))|0);
4109       $i=$34;
4110       __label__ = 5; break;
4111     case 8:
4112       var $36=$2;
4113       var $37=(($36+132)|0);
4114       var $38=HEAP32[(($37)>>2)];
4115       var $39=((($38)-(1))|0);
4116       HEAP32[(($37)>>2)]=$39;
4117       var $40=$2;
4118       var $41=(($40+132)|0);
4119       var $42=HEAP32[(($41)>>2)];
4120       var $43=$2;
4121       var $44=(($43+132)|0);
4122       var $45=HEAP32[(($44)>>2)];
4123       var $46=Math.floor(((($45)>>>0))/(2));
4124       var $47=(($42)>>>0) < (($46)>>>0);
4125       if ($47) { __label__ = 9; break; } else { __label__ = 12; break; }
4126     case 9:
4127       var $49=$2;
4128       var $50=(($49+136)|0);
4129       var $51=HEAP32[(($50)>>2)];
4130       var $52=Math.floor(((($51)>>>0))/(2));
4131       HEAP32[(($50)>>2)]=$52;
4132       var $53=$2;
4133       var $54=(($53+132)|0);
4134       var $55=HEAP32[(($54)>>2)];
4135       var $56=((($55<<2))|0);
4136       var $57=_util_memory_a($56, 51, ((STRING_TABLE.__str)|0));
4137       var $58=$57;
4138       $reall=$58;
4139       var $59=$reall;
4140       var $60=(($59)|0)!=0;
4141       if ($60) { __label__ = 11; break; } else { __label__ = 10; break; }
4142     case 10:
4143       $1=0;
4144       __label__ = 13; break;
4145     case 11:
4146       var $63=$reall;
4147       var $64=$63;
4148       var $65=$2;
4149       var $66=(($65+128)|0);
4150       var $67=HEAP32[(($66)>>2)];
4151       var $68=$67;
4152       var $69=$2;
4153       var $70=(($69+132)|0);
4154       var $71=HEAP32[(($70)>>2)];
4155       var $72=((($71<<2))|0);
4156       assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4);
4157       var $73=$2;
4158       var $74=(($73+128)|0);
4159       var $75=HEAP32[(($74)>>2)];
4160       var $76=$75;
4161       _util_memory_d($76, 51, ((STRING_TABLE.__str)|0));
4162       var $77=$reall;
4163       var $78=$2;
4164       var $79=(($78+128)|0);
4165       HEAP32[(($79)>>2)]=$77;
4166       __label__ = 12; break;
4167     case 12:
4168       $1=1;
4169       __label__ = 13; break;
4170     case 13:
4171       var $82=$1;
4172       ;
4173       return $82;
4174     default: assert(0, "bad label: " + __label__);
4175   }
4176 }
4177 _qc_program_builtins_remove["X"]=1;
4178
4179 function _qc_program_builtins_add($self, $f) {
4180   ;
4181   var __label__;
4182   __label__ = 2;
4183   while(1) switch(__label__) {
4184     case 2:
4185       var $1;
4186       var $2;
4187       var $3;
4188       var $reall;
4189       $2=$self;
4190       $3=$f;
4191       var $4=$2;
4192       var $5=(($4+132)|0);
4193       var $6=HEAP32[(($5)>>2)];
4194       var $7=$2;
4195       var $8=(($7+136)|0);
4196       var $9=HEAP32[(($8)>>2)];
4197       var $10=(($6)|0)==(($9)|0);
4198       if ($10) { __label__ = 3; break; } else { __label__ = 9; break; }
4199     case 3:
4200       var $12=$2;
4201       var $13=(($12+136)|0);
4202       var $14=HEAP32[(($13)>>2)];
4203       var $15=(($14)|0)!=0;
4204       if ($15) { __label__ = 5; break; } else { __label__ = 4; break; }
4205     case 4:
4206       var $17=$2;
4207       var $18=(($17+136)|0);
4208       HEAP32[(($18)>>2)]=16;
4209       __label__ = 6; break;
4210     case 5:
4211       var $20=$2;
4212       var $21=(($20+136)|0);
4213       var $22=HEAP32[(($21)>>2)];
4214       var $23=((($22<<1))|0);
4215       HEAP32[(($21)>>2)]=$23;
4216       __label__ = 6; break;
4217     case 6:
4218       var $25=$2;
4219       var $26=(($25+136)|0);
4220       var $27=HEAP32[(($26)>>2)];
4221       var $28=((($27<<2))|0);
4222       var $29=_util_memory_a($28, 51, ((STRING_TABLE.__str)|0));
4223       var $30=$29;
4224       $reall=$30;
4225       var $31=$reall;
4226       var $32=(($31)|0)!=0;
4227       if ($32) { __label__ = 8; break; } else { __label__ = 7; break; }
4228     case 7:
4229       $1=0;
4230       __label__ = 10; break;
4231     case 8:
4232       var $35=$reall;
4233       var $36=$35;
4234       var $37=$2;
4235       var $38=(($37+128)|0);
4236       var $39=HEAP32[(($38)>>2)];
4237       var $40=$39;
4238       var $41=$2;
4239       var $42=(($41+132)|0);
4240       var $43=HEAP32[(($42)>>2)];
4241       var $44=((($43<<2))|0);
4242       assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4);
4243       var $45=$2;
4244       var $46=(($45+128)|0);
4245       var $47=HEAP32[(($46)>>2)];
4246       var $48=$47;
4247       _util_memory_d($48, 51, ((STRING_TABLE.__str)|0));
4248       var $49=$reall;
4249       var $50=$2;
4250       var $51=(($50+128)|0);
4251       HEAP32[(($51)>>2)]=$49;
4252       __label__ = 9; break;
4253     case 9:
4254       var $53=$3;
4255       var $54=$2;
4256       var $55=(($54+132)|0);
4257       var $56=HEAP32[(($55)>>2)];
4258       var $57=((($56)+(1))|0);
4259       HEAP32[(($55)>>2)]=$57;
4260       var $58=$2;
4261       var $59=(($58+128)|0);
4262       var $60=HEAP32[(($59)>>2)];
4263       var $61=(($60+($56<<2))|0);
4264       HEAP32[(($61)>>2)]=$53;
4265       $1=1;
4266       __label__ = 10; break;
4267     case 10:
4268       var $63=$1;
4269       ;
4270       return $63;
4271     default: assert(0, "bad label: " + __label__);
4272   }
4273 }
4274 _qc_program_builtins_add["X"]=1;
4275
4276 function _prog_load($filename) {
4277   var __stackBase__  = STACKTOP; STACKTOP += 60; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
4278   var __label__;
4279   __label__ = 2;
4280   while(1) switch(__label__) {
4281     case 2:
4282       var $1;
4283       var $2;
4284       var $prog;
4285       var $header=__stackBase__;
4286       var $i;
4287       var $file;
4288       $2=$filename;
4289       var $3=$2;
4290       var $4=_util_fopen($3, ((STRING_TABLE.__str1)|0));
4291       $file=$4;
4292       var $5=$file;
4293       var $6=(($5)|0)!=0;
4294       if ($6) { __label__ = 4; break; } else { __label__ = 3; break; }
4295     case 3:
4296       $1=0;
4297       __label__ = 80; break;
4298     case 4:
4299       var $9=$header;
4300       var $10=$file;
4301       var $11=_fread($9, 60, 1, $10);
4302       var $12=(($11)|0)!=1;
4303       if ($12) { __label__ = 5; break; } else { __label__ = 6; break; }
4304     case 5:
4305       var $14=$2;
4306       _loaderror(((STRING_TABLE.__str2)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$14,tempInt));
4307       var $15=$file;
4308       var $16=_fclose($15);
4309       $1=0;
4310       __label__ = 80; break;
4311     case 6:
4312       var $18=(($header)|0);
4313       var $19=HEAP32[(($18)>>2)];
4314       var $20=(($19)|0)!=6;
4315       if ($20) { __label__ = 7; break; } else { __label__ = 8; break; }
4316     case 7:
4317       var $22=(($header)|0);
4318       var $23=HEAP32[(($22)>>2)];
4319       _loaderror(((STRING_TABLE.__str3)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$23,tempInt));
4320       var $24=$file;
4321       var $25=_fclose($24);
4322       $1=0;
4323       __label__ = 80; break;
4324     case 8:
4325       var $27=_util_memory_a(188, 98, ((STRING_TABLE.__str)|0));
4326       var $28=$27;
4327       $prog=$28;
4328       var $29=$prog;
4329       var $30=(($29)|0)!=0;
4330       if ($30) { __label__ = 10; break; } else { __label__ = 9; break; }
4331     case 9:
4332       var $32=$file;
4333       var $33=_fclose($32);
4334       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));
4335       $1=0;
4336       __label__ = 80; break;
4337     case 10:
4338       var $36=$prog;
4339       var $37=$36;
4340       for (var $$dest = $37>>2, $$stop = $$dest + 47; $$dest < $$stop; $$dest++) {
4341         HEAP32[$$dest] = 0
4342       };
4343       var $38=(($header+56)|0);
4344       var $39=HEAP32[(($38)>>2)];
4345       var $40=$prog;
4346       var $41=(($40+144)|0);
4347       HEAP32[(($41)>>2)]=$39;
4348       var $42=(($header+4)|0);
4349       var $43=HEAP16[(($42)>>1)];
4350       var $44=$prog;
4351       var $45=(($44+100)|0);
4352       HEAP16[(($45)>>1)]=$43;
4353       var $46=$2;
4354       var $47=_util_strdup($46);
4355       var $48=$prog;
4356       var $49=(($48)|0);
4357       HEAP32[(($49)>>2)]=$47;
4358       var $50=$prog;
4359       var $51=(($50)|0);
4360       var $52=HEAP32[(($51)>>2)];
4361       var $53=(($52)|0)!=0;
4362       if ($53) { __label__ = 12; break; } else { __label__ = 11; break; }
4363     case 11:
4364       _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));
4365       __label__ = 61; break;
4366     case 12:
4367       var $56=$file;
4368       var $57=(($header+8)|0);
4369       var $58=(($57)|0);
4370       var $59=HEAP32[(($58)>>2)];
4371       var $60=_fseek($56, $59, 0);
4372       var $61=(($60)|0)!=0;
4373       if ($61) { __label__ = 13; break; } else { __label__ = 14; break; }
4374     case 13:
4375       _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));
4376       __label__ = 61; break;
4377     case 14:
4378       var $64=(($header+8)|0);
4379       var $65=(($64+4)|0);
4380       var $66=HEAP32[(($65)>>2)];
4381       var $67=$prog;
4382       var $68=(($67+12)|0);
4383       HEAP32[(($68)>>2)]=$66;
4384       var $69=(($header+8)|0);
4385       var $70=(($69+4)|0);
4386       var $71=HEAP32[(($70)>>2)];
4387       var $72=$prog;
4388       var $73=(($72+8)|0);
4389       HEAP32[(($73)>>2)]=$71;
4390       var $74=(($header+8)|0);
4391       var $75=(($74+4)|0);
4392       var $76=HEAP32[(($75)>>2)];
4393       var $77=((($76<<3))|0);
4394       var $78=_util_memory_a($77, 132, ((STRING_TABLE.__str)|0));
4395       var $79=$78;
4396       var $80=$prog;
4397       var $81=(($80+4)|0);
4398       HEAP32[(($81)>>2)]=$79;
4399       var $82=$prog;
4400       var $83=(($82+4)|0);
4401       var $84=HEAP32[(($83)>>2)];
4402       var $85=(($84)|0)!=0;
4403       if ($85) { __label__ = 16; break; } else { __label__ = 15; break; }
4404     case 15:
4405       __label__ = 61; break;
4406     case 16:
4407       var $88=$prog;
4408       var $89=(($88+4)|0);
4409       var $90=HEAP32[(($89)>>2)];
4410       var $91=$90;
4411       var $92=(($header+8)|0);
4412       var $93=(($92+4)|0);
4413       var $94=HEAP32[(($93)>>2)];
4414       var $95=$file;
4415       var $96=_fread($91, 8, $94, $95);
4416       var $97=(($header+8)|0);
4417       var $98=(($97+4)|0);
4418       var $99=HEAP32[(($98)>>2)];
4419       var $100=(($96)|0)!=(($99)|0);
4420       if ($100) { __label__ = 17; break; } else { __label__ = 18; break; }
4421     case 17:
4422       _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));
4423       __label__ = 61; break;
4424     case 18:
4425       var $103=$file;
4426       var $104=(($header+16)|0);
4427       var $105=(($104)|0);
4428       var $106=HEAP32[(($105)>>2)];
4429       var $107=_fseek($103, $106, 0);
4430       var $108=(($107)|0)!=0;
4431       if ($108) { __label__ = 19; break; } else { __label__ = 20; break; }
4432     case 19:
4433       _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));
4434       __label__ = 61; break;
4435     case 20:
4436       var $111=(($header+16)|0);
4437       var $112=(($111+4)|0);
4438       var $113=HEAP32[(($112)>>2)];
4439       var $114=$prog;
4440       var $115=(($114+24)|0);
4441       HEAP32[(($115)>>2)]=$113;
4442       var $116=(($header+16)|0);
4443       var $117=(($116+4)|0);
4444       var $118=HEAP32[(($117)>>2)];
4445       var $119=$prog;
4446       var $120=(($119+20)|0);
4447       HEAP32[(($120)>>2)]=$118;
4448       var $121=(($header+16)|0);
4449       var $122=(($121+4)|0);
4450       var $123=HEAP32[(($122)>>2)];
4451       var $124=((($123<<3))|0);
4452       var $125=_util_memory_a($124, 133, ((STRING_TABLE.__str)|0));
4453       var $126=$125;
4454       var $127=$prog;
4455       var $128=(($127+16)|0);
4456       HEAP32[(($128)>>2)]=$126;
4457       var $129=$prog;
4458       var $130=(($129+16)|0);
4459       var $131=HEAP32[(($130)>>2)];
4460       var $132=(($131)|0)!=0;
4461       if ($132) { __label__ = 22; break; } else { __label__ = 21; break; }
4462     case 21:
4463       __label__ = 61; break;
4464     case 22:
4465       var $135=$prog;
4466       var $136=(($135+16)|0);
4467       var $137=HEAP32[(($136)>>2)];
4468       var $138=$137;
4469       var $139=(($header+16)|0);
4470       var $140=(($139+4)|0);
4471       var $141=HEAP32[(($140)>>2)];
4472       var $142=$file;
4473       var $143=_fread($138, 8, $141, $142);
4474       var $144=(($header+16)|0);
4475       var $145=(($144+4)|0);
4476       var $146=HEAP32[(($145)>>2)];
4477       var $147=(($143)|0)!=(($146)|0);
4478       if ($147) { __label__ = 23; break; } else { __label__ = 24; break; }
4479     case 23:
4480       _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));
4481       __label__ = 61; break;
4482     case 24:
4483       var $150=$file;
4484       var $151=(($header+24)|0);
4485       var $152=(($151)|0);
4486       var $153=HEAP32[(($152)>>2)];
4487       var $154=_fseek($150, $153, 0);
4488       var $155=(($154)|0)!=0;
4489       if ($155) { __label__ = 25; break; } else { __label__ = 26; break; }
4490     case 25:
4491       _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));
4492       __label__ = 61; break;
4493     case 26:
4494       var $158=(($header+24)|0);
4495       var $159=(($158+4)|0);
4496       var $160=HEAP32[(($159)>>2)];
4497       var $161=$prog;
4498       var $162=(($161+36)|0);
4499       HEAP32[(($162)>>2)]=$160;
4500       var $163=(($header+24)|0);
4501       var $164=(($163+4)|0);
4502       var $165=HEAP32[(($164)>>2)];
4503       var $166=$prog;
4504       var $167=(($166+32)|0);
4505       HEAP32[(($167)>>2)]=$165;
4506       var $168=(($header+24)|0);
4507       var $169=(($168+4)|0);
4508       var $170=HEAP32[(($169)>>2)];
4509       var $171=((($170<<3))|0);
4510       var $172=_util_memory_a($171, 134, ((STRING_TABLE.__str)|0));
4511       var $173=$172;
4512       var $174=$prog;
4513       var $175=(($174+28)|0);
4514       HEAP32[(($175)>>2)]=$173;
4515       var $176=$prog;
4516       var $177=(($176+28)|0);
4517       var $178=HEAP32[(($177)>>2)];
4518       var $179=(($178)|0)!=0;
4519       if ($179) { __label__ = 28; break; } else { __label__ = 27; break; }
4520     case 27:
4521       __label__ = 61; break;
4522     case 28:
4523       var $182=$prog;
4524       var $183=(($182+28)|0);
4525       var $184=HEAP32[(($183)>>2)];
4526       var $185=$184;
4527       var $186=(($header+24)|0);
4528       var $187=(($186+4)|0);
4529       var $188=HEAP32[(($187)>>2)];
4530       var $189=$file;
4531       var $190=_fread($185, 8, $188, $189);
4532       var $191=(($header+24)|0);
4533       var $192=(($191+4)|0);
4534       var $193=HEAP32[(($192)>>2)];
4535       var $194=(($190)|0)!=(($193)|0);
4536       if ($194) { __label__ = 29; break; } else { __label__ = 30; break; }
4537     case 29:
4538       _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));
4539       __label__ = 61; break;
4540     case 30:
4541       var $197=$file;
4542       var $198=(($header+32)|0);
4543       var $199=(($198)|0);
4544       var $200=HEAP32[(($199)>>2)];
4545       var $201=_fseek($197, $200, 0);
4546       var $202=(($201)|0)!=0;
4547       if ($202) { __label__ = 31; break; } else { __label__ = 32; break; }
4548     case 31:
4549       _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));
4550       __label__ = 61; break;
4551     case 32:
4552       var $205=(($header+32)|0);
4553       var $206=(($205+4)|0);
4554       var $207=HEAP32[(($206)>>2)];
4555       var $208=$prog;
4556       var $209=(($208+48)|0);
4557       HEAP32[(($209)>>2)]=$207;
4558       var $210=(($header+32)|0);
4559       var $211=(($210+4)|0);
4560       var $212=HEAP32[(($211)>>2)];
4561       var $213=$prog;
4562       var $214=(($213+44)|0);
4563       HEAP32[(($214)>>2)]=$212;
4564       var $215=(($header+32)|0);
4565       var $216=(($215+4)|0);
4566       var $217=HEAP32[(($216)>>2)];
4567       var $218=((($217)*(36))|0);
4568       var $219=_util_memory_a($218, 135, ((STRING_TABLE.__str)|0));
4569       var $220=$219;
4570       var $221=$prog;
4571       var $222=(($221+40)|0);
4572       HEAP32[(($222)>>2)]=$220;
4573       var $223=$prog;
4574       var $224=(($223+40)|0);
4575       var $225=HEAP32[(($224)>>2)];
4576       var $226=(($225)|0)!=0;
4577       if ($226) { __label__ = 34; break; } else { __label__ = 33; break; }
4578     case 33:
4579       __label__ = 61; break;
4580     case 34:
4581       var $229=$prog;
4582       var $230=(($229+40)|0);
4583       var $231=HEAP32[(($230)>>2)];
4584       var $232=$231;
4585       var $233=(($header+32)|0);
4586       var $234=(($233+4)|0);
4587       var $235=HEAP32[(($234)>>2)];
4588       var $236=$file;
4589       var $237=_fread($232, 36, $235, $236);
4590       var $238=(($header+32)|0);
4591       var $239=(($238+4)|0);
4592       var $240=HEAP32[(($239)>>2)];
4593       var $241=(($237)|0)!=(($240)|0);
4594       if ($241) { __label__ = 35; break; } else { __label__ = 36; break; }
4595     case 35:
4596       _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));
4597       __label__ = 61; break;
4598     case 36:
4599       var $244=$file;
4600       var $245=(($header+40)|0);
4601       var $246=(($245)|0);
4602       var $247=HEAP32[(($246)>>2)];
4603       var $248=_fseek($244, $247, 0);
4604       var $249=(($248)|0)!=0;
4605       if ($249) { __label__ = 37; break; } else { __label__ = 38; break; }
4606     case 37:
4607       _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));
4608       __label__ = 61; break;
4609     case 38:
4610       var $252=(($header+40)|0);
4611       var $253=(($252+4)|0);
4612       var $254=HEAP32[(($253)>>2)];
4613       var $255=$prog;
4614       var $256=(($255+60)|0);
4615       HEAP32[(($256)>>2)]=$254;
4616       var $257=(($header+40)|0);
4617       var $258=(($257+4)|0);
4618       var $259=HEAP32[(($258)>>2)];
4619       var $260=$prog;
4620       var $261=(($260+56)|0);
4621       HEAP32[(($261)>>2)]=$259;
4622       var $262=(($header+40)|0);
4623       var $263=(($262+4)|0);
4624       var $264=HEAP32[(($263)>>2)];
4625       var $265=(($264)|0);
4626       var $266=_util_memory_a($265, 136, ((STRING_TABLE.__str)|0));
4627       var $267=$prog;
4628       var $268=(($267+52)|0);
4629       HEAP32[(($268)>>2)]=$266;
4630       var $269=$prog;
4631       var $270=(($269+52)|0);
4632       var $271=HEAP32[(($270)>>2)];
4633       var $272=(($271)|0)!=0;
4634       if ($272) { __label__ = 40; break; } else { __label__ = 39; break; }
4635     case 39:
4636       __label__ = 61; break;
4637     case 40:
4638       var $275=$prog;
4639       var $276=(($275+52)|0);
4640       var $277=HEAP32[(($276)>>2)];
4641       var $278=(($header+40)|0);
4642       var $279=(($278+4)|0);
4643       var $280=HEAP32[(($279)>>2)];
4644       var $281=$file;
4645       var $282=_fread($277, 1, $280, $281);
4646       var $283=(($header+40)|0);
4647       var $284=(($283+4)|0);
4648       var $285=HEAP32[(($284)>>2)];
4649       var $286=(($282)|0)!=(($285)|0);
4650       if ($286) { __label__ = 41; break; } else { __label__ = 42; break; }
4651     case 41:
4652       _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));
4653       __label__ = 61; break;
4654     case 42:
4655       var $289=$file;
4656       var $290=(($header+48)|0);
4657       var $291=(($290)|0);
4658       var $292=HEAP32[(($291)>>2)];
4659       var $293=_fseek($289, $292, 0);
4660       var $294=(($293)|0)!=0;
4661       if ($294) { __label__ = 43; break; } else { __label__ = 44; break; }
4662     case 43:
4663       _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));
4664       __label__ = 61; break;
4665     case 44:
4666       var $297=(($header+48)|0);
4667       var $298=(($297+4)|0);
4668       var $299=HEAP32[(($298)>>2)];
4669       var $300=$prog;
4670       var $301=(($300+72)|0);
4671       HEAP32[(($301)>>2)]=$299;
4672       var $302=(($header+48)|0);
4673       var $303=(($302+4)|0);
4674       var $304=HEAP32[(($303)>>2)];
4675       var $305=$prog;
4676       var $306=(($305+68)|0);
4677       HEAP32[(($306)>>2)]=$304;
4678       var $307=(($header+48)|0);
4679       var $308=(($307+4)|0);
4680       var $309=HEAP32[(($308)>>2)];
4681       var $310=((($309<<2))|0);
4682       var $311=_util_memory_a($310, 137, ((STRING_TABLE.__str)|0));
4683       var $312=$311;
4684       var $313=$prog;
4685       var $314=(($313+64)|0);
4686       HEAP32[(($314)>>2)]=$312;
4687       var $315=$prog;
4688       var $316=(($315+64)|0);
4689       var $317=HEAP32[(($316)>>2)];
4690       var $318=(($317)|0)!=0;
4691       if ($318) { __label__ = 46; break; } else { __label__ = 45; break; }
4692     case 45:
4693       __label__ = 61; break;
4694     case 46:
4695       var $321=$prog;
4696       var $322=(($321+64)|0);
4697       var $323=HEAP32[(($322)>>2)];
4698       var $324=$323;
4699       var $325=(($header+48)|0);
4700       var $326=(($325+4)|0);
4701       var $327=HEAP32[(($326)>>2)];
4702       var $328=$file;
4703       var $329=_fread($324, 4, $327, $328);
4704       var $330=(($header+48)|0);
4705       var $331=(($330+4)|0);
4706       var $332=HEAP32[(($331)>>2)];
4707       var $333=(($329)|0)!=(($332)|0);
4708       if ($333) { __label__ = 47; break; } else { __label__ = 48; break; }
4709     case 47:
4710       _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));
4711       __label__ = 61; break;
4712     case 48:
4713       var $336=$file;
4714       var $337=_fclose($336);
4715       var $338=$prog;
4716       var $339=$prog;
4717       var $340=(($339+8)|0);
4718       var $341=HEAP32[(($340)>>2)];
4719       var $342=_qc_program_profile_resize($338, $341);
4720       if ($342) { __label__ = 50; break; } else { __label__ = 49; break; }
4721     case 49:
4722       __label__ = 61; break;
4723     case 50:
4724       var $345=$prog;
4725       var $346=(($345+56)|0);
4726       var $347=HEAP32[(($346)>>2)];
4727       var $348=$prog;
4728       var $349=(($348+104)|0);
4729       HEAP32[(($349)>>2)]=$347;
4730       var $350=$prog;
4731       var $351=(($350+56)|0);
4732       var $352=HEAP32[(($351)>>2)];
4733       var $353=$prog;
4734       var $354=(($353+108)|0);
4735       HEAP32[(($354)>>2)]=$352;
4736       var $355=$prog;
4737       var $356=$prog;
4738       var $357=(($356+56)|0);
4739       var $358=HEAP32[(($357)>>2)];
4740       var $359=((($358)+(16384))|0);
4741       var $360=_qc_program_strings_resize($355, $359);
4742       if ($360) { __label__ = 52; break; } else { __label__ = 51; break; }
4743     case 51:
4744       __label__ = 61; break;
4745     case 52:
4746       var $363=$prog;
4747       var $364=_qc_program_entitypool_add($363, 1);
4748       if ($364) { __label__ = 54; break; } else { __label__ = 53; break; }
4749     case 53:
4750       _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));
4751       __label__ = 61; break;
4752     case 54:
4753       $i=0;
4754       __label__ = 55; break;
4755     case 55:
4756       var $368=$i;
4757       var $369=$prog;
4758       var $370=(($369+144)|0);
4759       var $371=HEAP32[(($370)>>2)];
4760       var $372=(($368)>>>0) < (($371)>>>0);
4761       if ($372) { __label__ = 56; break; } else { __label__ = 60; break; }
4762     case 56:
4763       var $374=$prog;
4764       var $375=_qc_program_entitydata_add($374, 0);
4765       if ($375) { __label__ = 58; break; } else { __label__ = 57; break; }
4766     case 57:
4767       _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));
4768       __label__ = 61; break;
4769     case 58:
4770       __label__ = 59; break;
4771     case 59:
4772       var $379=$i;
4773       var $380=((($379)+(1))|0);
4774       $i=$380;
4775       __label__ = 55; break;
4776     case 60:
4777       var $382=$prog;
4778       var $383=(($382+140)|0);
4779       HEAP32[(($383)>>2)]=1;
4780       var $384=$prog;
4781       $1=$384;
4782       __label__ = 80; break;
4783     case 61:
4784       var $386=$prog;
4785       var $387=(($386)|0);
4786       var $388=HEAP32[(($387)>>2)];
4787       var $389=(($388)|0)!=0;
4788       if ($389) { __label__ = 62; break; } else { __label__ = 63; break; }
4789     case 62:
4790       var $391=$prog;
4791       var $392=(($391)|0);
4792       var $393=HEAP32[(($392)>>2)];
4793       _util_memory_d($393, 167, ((STRING_TABLE.__str)|0));
4794       __label__ = 63; break;
4795     case 63:
4796       var $395=$prog;
4797       var $396=(($395+4)|0);
4798       var $397=HEAP32[(($396)>>2)];
4799       var $398=(($397)|0)!=0;
4800       if ($398) { __label__ = 64; break; } else { __label__ = 65; break; }
4801     case 64:
4802       var $400=$prog;
4803       var $401=(($400+4)|0);
4804       var $402=HEAP32[(($401)>>2)];
4805       var $403=$402;
4806       _util_memory_d($403, 168, ((STRING_TABLE.__str)|0));
4807       __label__ = 65; break;
4808     case 65:
4809       var $405=$prog;
4810       var $406=(($405+16)|0);
4811       var $407=HEAP32[(($406)>>2)];
4812       var $408=(($407)|0)!=0;
4813       if ($408) { __label__ = 66; break; } else { __label__ = 67; break; }
4814     case 66:
4815       var $410=$prog;
4816       var $411=(($410+16)|0);
4817       var $412=HEAP32[(($411)>>2)];
4818       var $413=$412;
4819       _util_memory_d($413, 169, ((STRING_TABLE.__str)|0));
4820       __label__ = 67; break;
4821     case 67:
4822       var $415=$prog;
4823       var $416=(($415+28)|0);
4824       var $417=HEAP32[(($416)>>2)];
4825       var $418=(($417)|0)!=0;
4826       if ($418) { __label__ = 68; break; } else { __label__ = 69; break; }
4827     case 68:
4828       var $420=$prog;
4829       var $421=(($420+28)|0);
4830       var $422=HEAP32[(($421)>>2)];
4831       var $423=$422;
4832       _util_memory_d($423, 170, ((STRING_TABLE.__str)|0));
4833       __label__ = 69; break;
4834     case 69:
4835       var $425=$prog;
4836       var $426=(($425+40)|0);
4837       var $427=HEAP32[(($426)>>2)];
4838       var $428=(($427)|0)!=0;
4839       if ($428) { __label__ = 70; break; } else { __label__ = 71; break; }
4840     case 70:
4841       var $430=$prog;
4842       var $431=(($430+40)|0);
4843       var $432=HEAP32[(($431)>>2)];
4844       var $433=$432;
4845       _util_memory_d($433, 171, ((STRING_TABLE.__str)|0));
4846       __label__ = 71; break;
4847     case 71:
4848       var $435=$prog;
4849       var $436=(($435+52)|0);
4850       var $437=HEAP32[(($436)>>2)];
4851       var $438=(($437)|0)!=0;
4852       if ($438) { __label__ = 72; break; } else { __label__ = 73; break; }
4853     case 72:
4854       var $440=$prog;
4855       var $441=(($440+52)|0);
4856       var $442=HEAP32[(($441)>>2)];
4857       _util_memory_d($442, 172, ((STRING_TABLE.__str)|0));
4858       __label__ = 73; break;
4859     case 73:
4860       var $444=$prog;
4861       var $445=(($444+64)|0);
4862       var $446=HEAP32[(($445)>>2)];
4863       var $447=(($446)|0)!=0;
4864       if ($447) { __label__ = 74; break; } else { __label__ = 75; break; }
4865     case 74:
4866       var $449=$prog;
4867       var $450=(($449+64)|0);
4868       var $451=HEAP32[(($450)>>2)];
4869       var $452=$451;
4870       _util_memory_d($452, 173, ((STRING_TABLE.__str)|0));
4871       __label__ = 75; break;
4872     case 75:
4873       var $454=$prog;
4874       var $455=(($454+76)|0);
4875       var $456=HEAP32[(($455)>>2)];
4876       var $457=(($456)|0)!=0;
4877       if ($457) { __label__ = 76; break; } else { __label__ = 77; break; }
4878     case 76:
4879       var $459=$prog;
4880       var $460=(($459+76)|0);
4881       var $461=HEAP32[(($460)>>2)];
4882       var $462=$461;
4883       _util_memory_d($462, 174, ((STRING_TABLE.__str)|0));
4884       __label__ = 77; break;
4885     case 77:
4886       var $464=$prog;
4887       var $465=(($464+88)|0);
4888       var $466=HEAP32[(($465)>>2)];
4889       var $467=(($466)|0)!=0;
4890       if ($467) { __label__ = 78; break; } else { __label__ = 79; break; }
4891     case 78:
4892       var $469=$prog;
4893       var $470=(($469+88)|0);
4894       var $471=HEAP32[(($470)>>2)];
4895       _util_memory_d($471, 175, ((STRING_TABLE.__str)|0));
4896       __label__ = 79; break;
4897     case 79:
4898       var $473=$prog;
4899       var $474=$473;
4900       _util_memory_d($474, 176, ((STRING_TABLE.__str)|0));
4901       $1=0;
4902       __label__ = 80; break;
4903     case 80:
4904       var $476=$1;
4905       STACKTOP = __stackBase__;
4906       return $476;
4907     default: assert(0, "bad label: " + __label__);
4908   }
4909 }
4910 _prog_load["X"]=1;
4911
4912 function _loaderror($fmt) {
4913   var __stackBase__  = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
4914   var __label__;
4915
4916   var $1;
4917   var $err;
4918   var $ap=__stackBase__;
4919   $1=$fmt;
4920   var $2=___errno();
4921   var $3=HEAP32[(($2)>>2)];
4922   $err=$3;
4923   var $4=$ap;
4924   HEAP32[(($4)>>2)]=arguments[_loaderror.length];
4925   var $5=$1;
4926   var $6=HEAP32[(($ap)>>2)];
4927   var $7=_vprintf($5, $6);
4928   var $8=$ap;
4929   ;
4930   var $9=$err;
4931   var $10=_strerror($9);
4932   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));
4933   STACKTOP = __stackBase__;
4934   return;
4935 }
4936
4937
4938 function _prog_getstring($prog, $str) {
4939   ;
4940   var __label__;
4941   __label__ = 2;
4942   while(1) switch(__label__) {
4943     case 2:
4944       var $1;
4945       var $2;
4946       var $3;
4947       $2=$prog;
4948       $3=$str;
4949       var $4=$3;
4950       var $5=(($4)|0) < 0;
4951       if ($5) { __label__ = 4; break; } else { __label__ = 3; break; }
4952     case 3:
4953       var $7=$3;
4954       var $8=$2;
4955       var $9=(($8+56)|0);
4956       var $10=HEAP32[(($9)>>2)];
4957       var $11=(($7)>>>0) >= (($10)>>>0);
4958       if ($11) { __label__ = 4; break; } else { __label__ = 5; break; }
4959     case 4:
4960       $1=((STRING_TABLE.__str10)|0);
4961       __label__ = 6; break;
4962     case 5:
4963       var $14=$2;
4964       var $15=(($14+52)|0);
4965       var $16=HEAP32[(($15)>>2)];
4966       var $17=$3;
4967       var $18=(($16+$17)|0);
4968       $1=$18;
4969       __label__ = 6; break;
4970     case 6:
4971       var $20=$1;
4972       ;
4973       return $20;
4974     default: assert(0, "bad label: " + __label__);
4975   }
4976 }
4977
4978
4979 function _prog_entfield($prog, $off) {
4980   ;
4981   var __label__;
4982   __label__ = 2;
4983   while(1) switch(__label__) {
4984     case 2:
4985       var $1;
4986       var $2;
4987       var $3;
4988       var $i;
4989       $2=$prog;
4990       $3=$off;
4991       $i=0;
4992       __label__ = 3; break;
4993     case 3:
4994       var $5=$i;
4995       var $6=$2;
4996       var $7=(($6+32)|0);
4997       var $8=HEAP32[(($7)>>2)];
4998       var $9=(($5)>>>0) < (($8)>>>0);
4999       if ($9) { __label__ = 4; break; } else { __label__ = 8; break; }
5000     case 4:
5001       var $11=$i;
5002       var $12=$2;
5003       var $13=(($12+28)|0);
5004       var $14=HEAP32[(($13)>>2)];
5005       var $15=(($14+($11<<3))|0);
5006       var $16=(($15+2)|0);
5007       var $17=HEAP16[(($16)>>1)];
5008       var $18=(($17)&65535);
5009       var $19=$3;
5010       var $20=(($18)|0)==(($19)|0);
5011       if ($20) { __label__ = 5; break; } else { __label__ = 6; break; }
5012     case 5:
5013       var $22=$2;
5014       var $23=(($22+28)|0);
5015       var $24=HEAP32[(($23)>>2)];
5016       var $25=$i;
5017       var $26=(($24+($25<<3))|0);
5018       $1=$26;
5019       __label__ = 9; break;
5020     case 6:
5021       __label__ = 7; break;
5022     case 7:
5023       var $29=$i;
5024       var $30=((($29)+(1))|0);
5025       $i=$30;
5026       __label__ = 3; break;
5027     case 8:
5028       $1=0;
5029       __label__ = 9; break;
5030     case 9:
5031       var $33=$1;
5032       ;
5033       return $33;
5034     default: assert(0, "bad label: " + __label__);
5035   }
5036 }
5037
5038
5039 function _prog_getdef($prog, $off) {
5040   ;
5041   var __label__;
5042   __label__ = 2;
5043   while(1) switch(__label__) {
5044     case 2:
5045       var $1;
5046       var $2;
5047       var $3;
5048       var $i;
5049       $2=$prog;
5050       $3=$off;
5051       $i=0;
5052       __label__ = 3; break;
5053     case 3:
5054       var $5=$i;
5055       var $6=$2;
5056       var $7=(($6+20)|0);
5057       var $8=HEAP32[(($7)>>2)];
5058       var $9=(($5)>>>0) < (($8)>>>0);
5059       if ($9) { __label__ = 4; break; } else { __label__ = 8; break; }
5060     case 4:
5061       var $11=$i;
5062       var $12=$2;
5063       var $13=(($12+16)|0);
5064       var $14=HEAP32[(($13)>>2)];
5065       var $15=(($14+($11<<3))|0);
5066       var $16=(($15+2)|0);
5067       var $17=HEAP16[(($16)>>1)];
5068       var $18=(($17)&65535);
5069       var $19=$3;
5070       var $20=(($18)|0)==(($19)|0);
5071       if ($20) { __label__ = 5; break; } else { __label__ = 6; break; }
5072     case 5:
5073       var $22=$2;
5074       var $23=(($22+16)|0);
5075       var $24=HEAP32[(($23)>>2)];
5076       var $25=$i;
5077       var $26=(($24+($25<<3))|0);
5078       $1=$26;
5079       __label__ = 9; break;
5080     case 6:
5081       __label__ = 7; break;
5082     case 7:
5083       var $29=$i;
5084       var $30=((($29)+(1))|0);
5085       $i=$30;
5086       __label__ = 3; break;
5087     case 8:
5088       $1=0;
5089       __label__ = 9; break;
5090     case 9:
5091       var $33=$1;
5092       ;
5093       return $33;
5094     default: assert(0, "bad label: " + __label__);
5095   }
5096 }
5097
5098
5099 function _prog_delete($prog) {
5100   ;
5101   var __label__;
5102   __label__ = 2;
5103   while(1) switch(__label__) {
5104     case 2:
5105       var $1;
5106       $1=$prog;
5107       var $2=$1;
5108       var $3=(($2)|0);
5109       var $4=HEAP32[(($3)>>2)];
5110       var $5=(($4)|0)!=0;
5111       if ($5) { __label__ = 3; break; } else { __label__ = 4; break; }
5112     case 3:
5113       var $7=$1;
5114       var $8=(($7)|0);
5115       var $9=HEAP32[(($8)>>2)];
5116       _util_memory_d($9, 182, ((STRING_TABLE.__str)|0));
5117       __label__ = 4; break;
5118     case 4:
5119       var $11=$1;
5120       var $12=(($11+4)|0);
5121       var $13=HEAP32[(($12)>>2)];
5122       var $14=(($13)|0)!=0;
5123       if ($14) { __label__ = 5; break; } else { __label__ = 6; break; }
5124     case 5:
5125       var $16=$1;
5126       var $17=(($16+4)|0);
5127       var $18=HEAP32[(($17)>>2)];
5128       var $19=$18;
5129       _util_memory_d($19, 183, ((STRING_TABLE.__str)|0));
5130       __label__ = 6; break;
5131     case 6:
5132       var $21=$1;
5133       var $22=(($21+4)|0);
5134       HEAP32[(($22)>>2)]=0;
5135       var $23=$1;
5136       var $24=(($23+8)|0);
5137       HEAP32[(($24)>>2)]=0;
5138       var $25=$1;
5139       var $26=(($25+12)|0);
5140       HEAP32[(($26)>>2)]=0;
5141       var $27=$1;
5142       var $28=(($27+16)|0);
5143       var $29=HEAP32[(($28)>>2)];
5144       var $30=(($29)|0)!=0;
5145       if ($30) { __label__ = 7; break; } else { __label__ = 8; break; }
5146     case 7:
5147       var $32=$1;
5148       var $33=(($32+16)|0);
5149       var $34=HEAP32[(($33)>>2)];
5150       var $35=$34;
5151       _util_memory_d($35, 184, ((STRING_TABLE.__str)|0));
5152       __label__ = 8; break;
5153     case 8:
5154       var $37=$1;
5155       var $38=(($37+16)|0);
5156       HEAP32[(($38)>>2)]=0;
5157       var $39=$1;
5158       var $40=(($39+20)|0);
5159       HEAP32[(($40)>>2)]=0;
5160       var $41=$1;
5161       var $42=(($41+24)|0);
5162       HEAP32[(($42)>>2)]=0;
5163       var $43=$1;
5164       var $44=(($43+28)|0);
5165       var $45=HEAP32[(($44)>>2)];
5166       var $46=(($45)|0)!=0;
5167       if ($46) { __label__ = 9; break; } else { __label__ = 10; break; }
5168     case 9:
5169       var $48=$1;
5170       var $49=(($48+28)|0);
5171       var $50=HEAP32[(($49)>>2)];
5172       var $51=$50;
5173       _util_memory_d($51, 185, ((STRING_TABLE.__str)|0));
5174       __label__ = 10; break;
5175     case 10:
5176       var $53=$1;
5177       var $54=(($53+28)|0);
5178       HEAP32[(($54)>>2)]=0;
5179       var $55=$1;
5180       var $56=(($55+32)|0);
5181       HEAP32[(($56)>>2)]=0;
5182       var $57=$1;
5183       var $58=(($57+36)|0);
5184       HEAP32[(($58)>>2)]=0;
5185       var $59=$1;
5186       var $60=(($59+40)|0);
5187       var $61=HEAP32[(($60)>>2)];
5188       var $62=(($61)|0)!=0;
5189       if ($62) { __label__ = 11; break; } else { __label__ = 12; break; }
5190     case 11:
5191       var $64=$1;
5192       var $65=(($64+40)|0);
5193       var $66=HEAP32[(($65)>>2)];
5194       var $67=$66;
5195       _util_memory_d($67, 186, ((STRING_TABLE.__str)|0));
5196       __label__ = 12; break;
5197     case 12:
5198       var $69=$1;
5199       var $70=(($69+40)|0);
5200       HEAP32[(($70)>>2)]=0;
5201       var $71=$1;
5202       var $72=(($71+44)|0);
5203       HEAP32[(($72)>>2)]=0;
5204       var $73=$1;
5205       var $74=(($73+48)|0);
5206       HEAP32[(($74)>>2)]=0;
5207       var $75=$1;
5208       var $76=(($75+52)|0);
5209       var $77=HEAP32[(($76)>>2)];
5210       var $78=(($77)|0)!=0;
5211       if ($78) { __label__ = 13; break; } else { __label__ = 14; break; }
5212     case 13:
5213       var $80=$1;
5214       var $81=(($80+52)|0);
5215       var $82=HEAP32[(($81)>>2)];
5216       _util_memory_d($82, 187, ((STRING_TABLE.__str)|0));
5217       __label__ = 14; break;
5218     case 14:
5219       var $84=$1;
5220       var $85=(($84+52)|0);
5221       HEAP32[(($85)>>2)]=0;
5222       var $86=$1;
5223       var $87=(($86+56)|0);
5224       HEAP32[(($87)>>2)]=0;
5225       var $88=$1;
5226       var $89=(($88+60)|0);
5227       HEAP32[(($89)>>2)]=0;
5228       var $90=$1;
5229       var $91=(($90+64)|0);
5230       var $92=HEAP32[(($91)>>2)];
5231       var $93=(($92)|0)!=0;
5232       if ($93) { __label__ = 15; break; } else { __label__ = 16; break; }
5233     case 15:
5234       var $95=$1;
5235       var $96=(($95+64)|0);
5236       var $97=HEAP32[(($96)>>2)];
5237       var $98=$97;
5238       _util_memory_d($98, 188, ((STRING_TABLE.__str)|0));
5239       __label__ = 16; break;
5240     case 16:
5241       var $100=$1;
5242       var $101=(($100+64)|0);
5243       HEAP32[(($101)>>2)]=0;
5244       var $102=$1;
5245       var $103=(($102+68)|0);
5246       HEAP32[(($103)>>2)]=0;
5247       var $104=$1;
5248       var $105=(($104+72)|0);
5249       HEAP32[(($105)>>2)]=0;
5250       var $106=$1;
5251       var $107=(($106+76)|0);
5252       var $108=HEAP32[(($107)>>2)];
5253       var $109=(($108)|0)!=0;
5254       if ($109) { __label__ = 17; break; } else { __label__ = 18; break; }
5255     case 17:
5256       var $111=$1;
5257       var $112=(($111+76)|0);
5258       var $113=HEAP32[(($112)>>2)];
5259       var $114=$113;
5260       _util_memory_d($114, 189, ((STRING_TABLE.__str)|0));
5261       __label__ = 18; break;
5262     case 18:
5263       var $116=$1;
5264       var $117=(($116+76)|0);
5265       HEAP32[(($117)>>2)]=0;
5266       var $118=$1;
5267       var $119=(($118+80)|0);
5268       HEAP32[(($119)>>2)]=0;
5269       var $120=$1;
5270       var $121=(($120+84)|0);
5271       HEAP32[(($121)>>2)]=0;
5272       var $122=$1;
5273       var $123=(($122+88)|0);
5274       var $124=HEAP32[(($123)>>2)];
5275       var $125=(($124)|0)!=0;
5276       if ($125) { __label__ = 19; break; } else { __label__ = 20; break; }
5277     case 19:
5278       var $127=$1;
5279       var $128=(($127+88)|0);
5280       var $129=HEAP32[(($128)>>2)];
5281       _util_memory_d($129, 190, ((STRING_TABLE.__str)|0));
5282       __label__ = 20; break;
5283     case 20:
5284       var $131=$1;
5285       var $132=(($131+88)|0);
5286       HEAP32[(($132)>>2)]=0;
5287       var $133=$1;
5288       var $134=(($133+92)|0);
5289       HEAP32[(($134)>>2)]=0;
5290       var $135=$1;
5291       var $136=(($135+96)|0);
5292       HEAP32[(($136)>>2)]=0;
5293       var $137=$1;
5294       var $138=(($137+152)|0);
5295       var $139=HEAP32[(($138)>>2)];
5296       var $140=(($139)|0)!=0;
5297       if ($140) { __label__ = 21; break; } else { __label__ = 22; break; }
5298     case 21:
5299       var $142=$1;
5300       var $143=(($142+152)|0);
5301       var $144=HEAP32[(($143)>>2)];
5302       var $145=$144;
5303       _util_memory_d($145, 191, ((STRING_TABLE.__str)|0));
5304       __label__ = 22; break;
5305     case 22:
5306       var $147=$1;
5307       var $148=(($147+152)|0);
5308       HEAP32[(($148)>>2)]=0;
5309       var $149=$1;
5310       var $150=(($149+156)|0);
5311       HEAP32[(($150)>>2)]=0;
5312       var $151=$1;
5313       var $152=(($151+160)|0);
5314       HEAP32[(($152)>>2)]=0;
5315       var $153=$1;
5316       var $154=(($153+164)|0);
5317       var $155=HEAP32[(($154)>>2)];
5318       var $156=(($155)|0)!=0;
5319       if ($156) { __label__ = 23; break; } else { __label__ = 24; break; }
5320     case 23:
5321       var $158=$1;
5322       var $159=(($158+164)|0);
5323       var $160=HEAP32[(($159)>>2)];
5324       var $161=$160;
5325       _util_memory_d($161, 192, ((STRING_TABLE.__str)|0));
5326       __label__ = 24; break;
5327     case 24:
5328       var $163=$1;
5329       var $164=(($163+164)|0);
5330       HEAP32[(($164)>>2)]=0;
5331       var $165=$1;
5332       var $166=(($165+168)|0);
5333       HEAP32[(($166)>>2)]=0;
5334       var $167=$1;
5335       var $168=(($167+172)|0);
5336       HEAP32[(($168)>>2)]=0;
5337       var $169=$1;
5338       var $170=(($169+116)|0);
5339       var $171=HEAP32[(($170)>>2)];
5340       var $172=(($171)|0)!=0;
5341       if ($172) { __label__ = 25; break; } else { __label__ = 26; break; }
5342     case 25:
5343       var $174=$1;
5344       var $175=(($174+116)|0);
5345       var $176=HEAP32[(($175)>>2)];
5346       var $177=$176;
5347       _util_memory_d($177, 193, ((STRING_TABLE.__str)|0));
5348       __label__ = 26; break;
5349     case 26:
5350       var $179=$1;
5351       var $180=(($179+116)|0);
5352       HEAP32[(($180)>>2)]=0;
5353       var $181=$1;
5354       var $182=(($181+120)|0);
5355       HEAP32[(($182)>>2)]=0;
5356       var $183=$1;
5357       var $184=(($183+124)|0);
5358       HEAP32[(($184)>>2)]=0;
5359       var $185=$1;
5360       var $186=(($185+136)|0);
5361       var $187=HEAP32[(($186)>>2)];
5362       var $188=(($187)|0)!=0;
5363       if ($188) { __label__ = 27; break; } else { __label__ = 30; break; }
5364     case 27:
5365       var $190=$1;
5366       var $191=(($190+128)|0);
5367       var $192=HEAP32[(($191)>>2)];
5368       var $193=(($192)|0)!=0;
5369       if ($193) { __label__ = 28; break; } else { __label__ = 29; break; }
5370     case 28:
5371       var $195=$1;
5372       var $196=(($195+128)|0);
5373       var $197=HEAP32[(($196)>>2)];
5374       var $198=$197;
5375       _util_memory_d($198, 196, ((STRING_TABLE.__str)|0));
5376       __label__ = 29; break;
5377     case 29:
5378       var $200=$1;
5379       var $201=(($200+128)|0);
5380       HEAP32[(($201)>>2)]=0;
5381       var $202=$1;
5382       var $203=(($202+132)|0);
5383       HEAP32[(($203)>>2)]=0;
5384       var $204=$1;
5385       var $205=(($204+136)|0);
5386       HEAP32[(($205)>>2)]=0;
5387       __label__ = 30; break;
5388     case 30:
5389       var $207=$1;
5390       var $208=$207;
5391       _util_memory_d($208, 199, ((STRING_TABLE.__str)|0));
5392       ;
5393       return;
5394     default: assert(0, "bad label: " + __label__);
5395   }
5396 }
5397 _prog_delete["X"]=1;
5398
5399 function _prog_getedict($prog, $e) {
5400   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5401   var __label__;
5402   __label__ = 2;
5403   while(1) switch(__label__) {
5404     case 2:
5405       var $1;
5406       var $2;
5407       $1=$prog;
5408       $2=$e;
5409       var $3=$2;
5410       var $4=$1;
5411       var $5=(($4+92)|0);
5412       var $6=HEAP32[(($5)>>2)];
5413       var $7=(($3)>>>0) >= (($6)>>>0);
5414       if ($7) { __label__ = 3; break; } else { __label__ = 4; break; }
5415     case 3:
5416       var $9=$1;
5417       var $10=(($9+112)|0);
5418       var $11=HEAP32[(($10)>>2)];
5419       var $12=((($11)+(1))|0);
5420       HEAP32[(($10)>>2)]=$12;
5421       var $13=$2;
5422       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));
5423       $2=0;
5424       __label__ = 4; break;
5425     case 4:
5426       var $16=$1;
5427       var $17=(($16+76)|0);
5428       var $18=HEAP32[(($17)>>2)];
5429       var $19=$1;
5430       var $20=(($19+144)|0);
5431       var $21=HEAP32[(($20)>>2)];
5432       var $22=$2;
5433       var $23=((($21)*($22))|0);
5434       var $24=(($18+($23<<2))|0);
5435       var $25=$24;
5436       STACKTOP = __stackBase__;
5437       return $25;
5438     default: assert(0, "bad label: " + __label__);
5439   }
5440 }
5441
5442
5443 function _prog_spawn_entity($prog) {
5444   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5445   var __label__;
5446   __label__ = 2;
5447   while(1) switch(__label__) {
5448     case 2:
5449       var $1;
5450       var $2;
5451       var $data;
5452       var $i;
5453       var $e;
5454       $2=$prog;
5455       $e=0;
5456       __label__ = 3; break;
5457     case 3:
5458       var $4=$e;
5459       var $5=$2;
5460       var $6=(($5+92)|0);
5461       var $7=HEAP32[(($6)>>2)];
5462       var $8=(($4)|0) < (($7)|0);
5463       if ($8) { __label__ = 4; break; } else { __label__ = 8; break; }
5464     case 4:
5465       var $10=$e;
5466       var $11=$2;
5467       var $12=(($11+88)|0);
5468       var $13=HEAP32[(($12)>>2)];
5469       var $14=(($13+$10)|0);
5470       var $15=HEAP8[($14)];
5471       var $16=(($15) & 1);
5472       if ($16) { __label__ = 6; break; } else { __label__ = 5; break; }
5473     case 5:
5474       var $18=$2;
5475       var $19=(($18+76)|0);
5476       var $20=HEAP32[(($19)>>2)];
5477       var $21=$2;
5478       var $22=(($21+144)|0);
5479       var $23=HEAP32[(($22)>>2)];
5480       var $24=$e;
5481       var $25=((($23)*($24))|0);
5482       var $26=(($20+($25<<2))|0);
5483       var $27=$26;
5484       $data=$27;
5485       var $28=$data;
5486       var $29=$2;
5487       var $30=(($29+144)|0);
5488       var $31=HEAP32[(($30)>>2)];
5489       var $32=((($31<<2))|0);
5490       _memset($28, 0, $32, 1);
5491       var $33=$e;
5492       $1=$33;
5493       __label__ = 17; break;
5494     case 6:
5495       __label__ = 7; break;
5496     case 7:
5497       var $36=$e;
5498       var $37=((($36)+(1))|0);
5499       $e=$37;
5500       __label__ = 3; break;
5501     case 8:
5502       var $39=$2;
5503       var $40=_qc_program_entitypool_add($39, 1);
5504       if ($40) { __label__ = 10; break; } else { __label__ = 9; break; }
5505     case 9:
5506       var $42=$2;
5507       var $43=(($42+112)|0);
5508       var $44=HEAP32[(($43)>>2)];
5509       var $45=((($44)+(1))|0);
5510       HEAP32[(($43)>>2)]=$45;
5511       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));
5512       $1=0;
5513       __label__ = 17; break;
5514     case 10:
5515       var $48=$2;
5516       var $49=(($48+140)|0);
5517       var $50=HEAP32[(($49)>>2)];
5518       var $51=((($50)+(1))|0);
5519       HEAP32[(($49)>>2)]=$51;
5520       $i=0;
5521       __label__ = 11; break;
5522     case 11:
5523       var $53=$i;
5524       var $54=$2;
5525       var $55=(($54+144)|0);
5526       var $56=HEAP32[(($55)>>2)];
5527       var $57=(($53)>>>0) < (($56)>>>0);
5528       if ($57) { __label__ = 12; break; } else { __label__ = 16; break; }
5529     case 12:
5530       var $59=$2;
5531       var $60=_qc_program_entitydata_add($59, 0);
5532       if ($60) { __label__ = 14; break; } else { __label__ = 13; break; }
5533     case 13:
5534       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));
5535       $1=0;
5536       __label__ = 17; break;
5537     case 14:
5538       __label__ = 15; break;
5539     case 15:
5540       var $65=$i;
5541       var $66=((($65)+(1))|0);
5542       $i=$66;
5543       __label__ = 11; break;
5544     case 16:
5545       var $68=$2;
5546       var $69=(($68+76)|0);
5547       var $70=HEAP32[(($69)>>2)];
5548       var $71=$2;
5549       var $72=(($71+144)|0);
5550       var $73=HEAP32[(($72)>>2)];
5551       var $74=$e;
5552       var $75=((($73)*($74))|0);
5553       var $76=(($70+($75<<2))|0);
5554       var $77=$76;
5555       $data=$77;
5556       var $78=$data;
5557       var $79=$2;
5558       var $80=(($79+144)|0);
5559       var $81=HEAP32[(($80)>>2)];
5560       var $82=((($81<<2))|0);
5561       _memset($78, 0, $82, 1);
5562       var $83=$e;
5563       $1=$83;
5564       __label__ = 17; break;
5565     case 17:
5566       var $85=$1;
5567       STACKTOP = __stackBase__;
5568       return $85;
5569     default: assert(0, "bad label: " + __label__);
5570   }
5571 }
5572 _prog_spawn_entity["X"]=1;
5573
5574 function _prog_free_entity($prog, $e) {
5575   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5576   var __label__;
5577   __label__ = 2;
5578   while(1) switch(__label__) {
5579     case 2:
5580       var $1;
5581       var $2;
5582       $1=$prog;
5583       $2=$e;
5584       var $3=$2;
5585       var $4=(($3)|0)!=0;
5586       if ($4) { __label__ = 4; break; } else { __label__ = 3; break; }
5587     case 3:
5588       var $6=$1;
5589       var $7=(($6+112)|0);
5590       var $8=HEAP32[(($7)>>2)];
5591       var $9=((($8)+(1))|0);
5592       HEAP32[(($7)>>2)]=$9;
5593       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));
5594       __label__ = 9; break;
5595     case 4:
5596       var $12=$2;
5597       var $13=$1;
5598       var $14=(($13+92)|0);
5599       var $15=HEAP32[(($14)>>2)];
5600       var $16=(($12)>>>0) >= (($15)>>>0);
5601       if ($16) { __label__ = 5; break; } else { __label__ = 6; break; }
5602     case 5:
5603       var $18=$1;
5604       var $19=(($18+112)|0);
5605       var $20=HEAP32[(($19)>>2)];
5606       var $21=((($20)+(1))|0);
5607       HEAP32[(($19)>>2)]=$21;
5608       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));
5609       __label__ = 9; break;
5610     case 6:
5611       var $24=$2;
5612       var $25=$1;
5613       var $26=(($25+88)|0);
5614       var $27=HEAP32[(($26)>>2)];
5615       var $28=(($27+$24)|0);
5616       var $29=HEAP8[($28)];
5617       var $30=(($29) & 1);
5618       if ($30) { __label__ = 8; break; } else { __label__ = 7; break; }
5619     case 7:
5620       var $32=$1;
5621       var $33=(($32+112)|0);
5622       var $34=HEAP32[(($33)>>2)];
5623       var $35=((($34)+(1))|0);
5624       HEAP32[(($33)>>2)]=$35;
5625       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));
5626       __label__ = 9; break;
5627     case 8:
5628       var $38=$2;
5629       var $39=$1;
5630       var $40=(($39+88)|0);
5631       var $41=HEAP32[(($40)>>2)];
5632       var $42=(($41+$38)|0);
5633       HEAP8[($42)]=0;
5634       __label__ = 9; break;
5635     case 9:
5636       STACKTOP = __stackBase__;
5637       return;
5638     default: assert(0, "bad label: " + __label__);
5639   }
5640 }
5641 _prog_free_entity["X"]=1;
5642
5643 function _prog_tempstring($prog, $_str) {
5644   ;
5645   var __label__;
5646   __label__ = 2;
5647   while(1) switch(__label__) {
5648     case 2:
5649       var $1;
5650       var $2;
5651       var $3;
5652       var $str;
5653       var $len;
5654       var $at;
5655       $2=$prog;
5656       $3=$_str;
5657       var $4=$3;
5658       $str=$4;
5659       var $5=$str;
5660       var $6=_strlen($5);
5661       $len=$6;
5662       var $7=$2;
5663       var $8=(($7+108)|0);
5664       var $9=HEAP32[(($8)>>2)];
5665       $at=$9;
5666       var $10=$at;
5667       var $11=$len;
5668       var $12=((($10)+($11))|0);
5669       var $13=$2;
5670       var $14=(($13+56)|0);
5671       var $15=HEAP32[(($14)>>2)];
5672       var $16=(($12)>>>0) >= (($15)>>>0);
5673       if ($16) { __label__ = 3; break; } else { __label__ = 4; break; }
5674     case 3:
5675       var $18=$2;
5676       var $19=(($18+104)|0);
5677       var $20=HEAP32[(($19)>>2)];
5678       $at=$20;
5679       __label__ = 4; break;
5680     case 4:
5681       var $22=$at;
5682       var $23=$len;
5683       var $24=((($22)+($23))|0);
5684       var $25=$2;
5685       var $26=(($25+56)|0);
5686       var $27=HEAP32[(($26)>>2)];
5687       var $28=(($24)>>>0) >= (($27)>>>0);
5688       if ($28) { __label__ = 5; break; } else { __label__ = 8; break; }
5689     case 5:
5690       var $30=$at;
5691       var $31=$2;
5692       var $32=(($31+56)|0);
5693       HEAP32[(($32)>>2)]=$30;
5694       var $33=$2;
5695       var $34=$str;
5696       var $35=$len;
5697       var $36=((($35)+(1))|0);
5698       var $37=_qc_program_strings_append($33, $34, $36);
5699       if ($37) { __label__ = 7; break; } else { __label__ = 6; break; }
5700     case 6:
5701       var $39=$2;
5702       var $40=(($39+112)|0);
5703       HEAP32[(($40)>>2)]=1;
5704       $1=0;
5705       __label__ = 9; break;
5706     case 7:
5707       var $42=$at;
5708       $1=$42;
5709       __label__ = 9; break;
5710     case 8:
5711       var $44=$2;
5712       var $45=(($44+52)|0);
5713       var $46=HEAP32[(($45)>>2)];
5714       var $47=$at;
5715       var $48=(($46+$47)|0);
5716       var $49=$str;
5717       var $50=$len;
5718       var $51=((($50)+(1))|0);
5719       assert($51 % 1 === 0, 'memcpy given ' + $51 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($48, $49, $51, 1);
5720       var $52=$len;
5721       var $53=((($52)+(1))|0);
5722       var $54=$2;
5723       var $55=(($54+108)|0);
5724       var $56=HEAP32[(($55)>>2)];
5725       var $57=((($56)+($53))|0);
5726       HEAP32[(($55)>>2)]=$57;
5727       var $58=$at;
5728       $1=$58;
5729       __label__ = 9; break;
5730     case 9:
5731       var $60=$1;
5732       ;
5733       return $60;
5734     default: assert(0, "bad label: " + __label__);
5735   }
5736 }
5737 _prog_tempstring["X"]=1;
5738
5739 function _prog_exec($prog, $func, $flags, $maxjumps) {
5740   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
5741   var __label__;
5742   __label__ = 2;
5743   while(1) switch(__label__) {
5744     case 2:
5745       var $1;
5746       var $2;
5747       var $3;
5748       var $4;
5749       var $5;
5750       var $jumpcount;
5751       var $oldxflags;
5752       var $st;
5753       var $newf;
5754       var $ed;
5755       var $ptr;
5756       var $builtinnumber;
5757       var $newf1;
5758       var $ed2;
5759       var $ptr3;
5760       var $builtinnumber4;
5761       var $newf5;
5762       var $ed6;
5763       var $ptr7;
5764       var $builtinnumber8;
5765       var $newf9;
5766       var $ed10;
5767       var $ptr11;
5768       var $builtinnumber12;
5769       $2=$prog;
5770       $3=$func;
5771       $4=$flags;
5772       $5=$maxjumps;
5773       $jumpcount=0;
5774       var $6=$2;
5775       var $7=(($6+180)|0);
5776       var $8=HEAP32[(($7)>>2)];
5777       $oldxflags=$8;
5778       var $9=$2;
5779       var $10=(($9+112)|0);
5780       HEAP32[(($10)>>2)]=0;
5781       var $11=$4;
5782       var $12=$2;
5783       var $13=(($12+180)|0);
5784       HEAP32[(($13)>>2)]=$11;
5785       var $14=$2;
5786       var $15=(($14+4)|0);
5787       var $16=HEAP32[(($15)>>2)];
5788       var $17=$2;
5789       var $18=$3;
5790       var $19=_prog_enterfunction($17, $18);
5791       var $20=(($16+($19<<3))|0);
5792       $st=$20;
5793       var $21=$st;
5794       var $22=((($21)-(8))|0);
5795       $st=$22;
5796       var $23=$4;
5797       if ((($23)|0) == 0) {
5798         __label__ = 4; break;
5799       }
5800       else if ((($23)|0) == 1) {
5801         __label__ = 125; break;
5802       }
5803       else if ((($23)|0) == 2) {
5804         __label__ = 246; break;
5805       }
5806       else if ((($23)|0) == 3) {
5807         __label__ = 367; break;
5808       }
5809       else {
5810       __label__ = 3; break;
5811       }
5812
5813     case 3:
5814       __label__ = 4; break;
5815     case 4:
5816       __label__ = 5; break;
5817     case 5:
5818       var $27=$st;
5819       var $28=(($27+8)|0);
5820       $st=$28;
5821       var $29=$st;
5822       var $30=(($29)|0);
5823       var $31=HEAP16[(($30)>>1)];
5824       var $32=(($31)&65535);
5825       if ((($32)|0) == 0 || (($32)|0) == 43) {
5826         __label__ = 7; break;
5827       }
5828       else if ((($32)|0) == 1) {
5829         __label__ = 10; break;
5830       }
5831       else if ((($32)|0) == 2) {
5832         __label__ = 11; break;
5833       }
5834       else if ((($32)|0) == 3) {
5835         __label__ = 12; break;
5836       }
5837       else if ((($32)|0) == 4) {
5838         __label__ = 13; break;
5839       }
5840       else if ((($32)|0) == 5) {
5841         __label__ = 14; break;
5842       }
5843       else if ((($32)|0) == 6) {
5844         __label__ = 18; break;
5845       }
5846       else if ((($32)|0) == 7) {
5847         __label__ = 19; break;
5848       }
5849       else if ((($32)|0) == 8) {
5850         __label__ = 20; break;
5851       }
5852       else if ((($32)|0) == 9) {
5853         __label__ = 21; break;
5854       }
5855       else if ((($32)|0) == 10) {
5856         __label__ = 22; break;
5857       }
5858       else if ((($32)|0) == 11) {
5859         __label__ = 23; break;
5860       }
5861       else if ((($32)|0) == 12) {
5862         __label__ = 27; break;
5863       }
5864       else if ((($32)|0) == 13) {
5865         __label__ = 28; break;
5866       }
5867       else if ((($32)|0) == 14) {
5868         __label__ = 29; break;
5869       }
5870       else if ((($32)|0) == 15) {
5871         __label__ = 30; break;
5872       }
5873       else if ((($32)|0) == 16) {
5874         __label__ = 31; break;
5875       }
5876       else if ((($32)|0) == 17) {
5877         __label__ = 35; break;
5878       }
5879       else if ((($32)|0) == 18) {
5880         __label__ = 36; break;
5881       }
5882       else if ((($32)|0) == 19) {
5883         __label__ = 37; break;
5884       }
5885       else if ((($32)|0) == 20) {
5886         __label__ = 38; break;
5887       }
5888       else if ((($32)|0) == 21) {
5889         __label__ = 39; break;
5890       }
5891       else if ((($32)|0) == 22) {
5892         __label__ = 40; break;
5893       }
5894       else if ((($32)|0) == 23) {
5895         __label__ = 41; break;
5896       }
5897       else if ((($32)|0) == 24 || (($32)|0) == 26 || (($32)|0) == 28 || (($32)|0) == 27 || (($32)|0) == 29) {
5898         __label__ = 42; break;
5899       }
5900       else if ((($32)|0) == 25) {
5901         __label__ = 48; break;
5902       }
5903       else if ((($32)|0) == 30) {
5904         __label__ = 55; break;
5905       }
5906       else if ((($32)|0) == 31 || (($32)|0) == 33 || (($32)|0) == 34 || (($32)|0) == 35 || (($32)|0) == 36) {
5907         __label__ = 61; break;
5908       }
5909       else if ((($32)|0) == 32) {
5910         __label__ = 62; break;
5911       }
5912       else if ((($32)|0) == 37 || (($32)|0) == 39 || (($32)|0) == 40 || (($32)|0) == 41 || (($32)|0) == 42) {
5913         __label__ = 63; break;
5914       }
5915       else if ((($32)|0) == 38) {
5916         __label__ = 70; break;
5917       }
5918       else if ((($32)|0) == 44) {
5919         __label__ = 77; break;
5920       }
5921       else if ((($32)|0) == 45) {
5922         __label__ = 78; break;
5923       }
5924       else if ((($32)|0) == 46) {
5925         __label__ = 82; break;
5926       }
5927       else if ((($32)|0) == 47) {
5928         __label__ = 85; break;
5929       }
5930       else if ((($32)|0) == 48) {
5931         __label__ = 86; break;
5932       }
5933       else if ((($32)|0) == 49) {
5934         __label__ = 87; break;
5935       }
5936       else if ((($32)|0) == 50) {
5937         __label__ = 92; break;
5938       }
5939       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) {
5940         __label__ = 97; break;
5941       }
5942       else if ((($32)|0) == 60) {
5943         __label__ = 112; break;
5944       }
5945       else if ((($32)|0) == 61) {
5946         __label__ = 113; break;
5947       }
5948       else if ((($32)|0) == 62) {
5949         __label__ = 116; break;
5950       }
5951       else if ((($32)|0) == 63) {
5952         __label__ = 119; break;
5953       }
5954       else if ((($32)|0) == 64) {
5955         __label__ = 122; break;
5956       }
5957       else if ((($32)|0) == 65) {
5958         __label__ = 123; break;
5959       }
5960       else {
5961       __label__ = 6; break;
5962       }
5963
5964     case 6:
5965       var $34=$2;
5966       var $35=$2;
5967       var $36=(($35)|0);
5968       var $37=HEAP32[(($36)>>2)];
5969       _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));
5970       __label__ = 488; break;
5971     case 7:
5972       var $39=$2;
5973       var $40=(($39+64)|0);
5974       var $41=HEAP32[(($40)>>2)];
5975       var $42=$st;
5976       var $43=(($42+2)|0);
5977       var $44=$43;
5978       var $45=HEAP16[(($44)>>1)];
5979       var $46=(($45)&65535);
5980       var $47=(($41+($46<<2))|0);
5981       var $48=$47;
5982       var $49=$48;
5983       var $50=(($49)|0);
5984       var $51=HEAP32[(($50)>>2)];
5985       var $52=$2;
5986       var $53=(($52+64)|0);
5987       var $54=HEAP32[(($53)>>2)];
5988       var $55=(($54+4)|0);
5989       var $56=$55;
5990       var $57=$56;
5991       var $58=(($57)|0);
5992       HEAP32[(($58)>>2)]=$51;
5993       var $59=$2;
5994       var $60=(($59+64)|0);
5995       var $61=HEAP32[(($60)>>2)];
5996       var $62=$st;
5997       var $63=(($62+2)|0);
5998       var $64=$63;
5999       var $65=HEAP16[(($64)>>1)];
6000       var $66=(($65)&65535);
6001       var $67=(($61+($66<<2))|0);
6002       var $68=$67;
6003       var $69=$68;
6004       var $70=(($69+4)|0);
6005       var $71=HEAP32[(($70)>>2)];
6006       var $72=$2;
6007       var $73=(($72+64)|0);
6008       var $74=HEAP32[(($73)>>2)];
6009       var $75=(($74+4)|0);
6010       var $76=$75;
6011       var $77=$76;
6012       var $78=(($77+4)|0);
6013       HEAP32[(($78)>>2)]=$71;
6014       var $79=$2;
6015       var $80=(($79+64)|0);
6016       var $81=HEAP32[(($80)>>2)];
6017       var $82=$st;
6018       var $83=(($82+2)|0);
6019       var $84=$83;
6020       var $85=HEAP16[(($84)>>1)];
6021       var $86=(($85)&65535);
6022       var $87=(($81+($86<<2))|0);
6023       var $88=$87;
6024       var $89=$88;
6025       var $90=(($89+8)|0);
6026       var $91=HEAP32[(($90)>>2)];
6027       var $92=$2;
6028       var $93=(($92+64)|0);
6029       var $94=HEAP32[(($93)>>2)];
6030       var $95=(($94+4)|0);
6031       var $96=$95;
6032       var $97=$96;
6033       var $98=(($97+8)|0);
6034       HEAP32[(($98)>>2)]=$91;
6035       var $99=$2;
6036       var $100=(($99+4)|0);
6037       var $101=HEAP32[(($100)>>2)];
6038       var $102=$2;
6039       var $103=_prog_leavefunction($102);
6040       var $104=(($101+($103<<3))|0);
6041       $st=$104;
6042       var $105=$2;
6043       var $106=(($105+168)|0);
6044       var $107=HEAP32[(($106)>>2)];
6045       var $108=(($107)|0)!=0;
6046       if ($108) { __label__ = 9; break; } else { __label__ = 8; break; }
6047     case 8:
6048       __label__ = 488; break;
6049     case 9:
6050       __label__ = 124; break;
6051     case 10:
6052       var $112=$2;
6053       var $113=(($112+64)|0);
6054       var $114=HEAP32[(($113)>>2)];
6055       var $115=$st;
6056       var $116=(($115+2)|0);
6057       var $117=$116;
6058       var $118=HEAP16[(($117)>>1)];
6059       var $119=(($118)&65535);
6060       var $120=(($114+($119<<2))|0);
6061       var $121=$120;
6062       var $122=$121;
6063       var $123=HEAPF32[(($122)>>2)];
6064       var $124=$2;
6065       var $125=(($124+64)|0);
6066       var $126=HEAP32[(($125)>>2)];
6067       var $127=$st;
6068       var $128=(($127+4)|0);
6069       var $129=$128;
6070       var $130=HEAP16[(($129)>>1)];
6071       var $131=(($130)&65535);
6072       var $132=(($126+($131<<2))|0);
6073       var $133=$132;
6074       var $134=$133;
6075       var $135=HEAPF32[(($134)>>2)];
6076       var $136=($123)*($135);
6077       var $137=$2;
6078       var $138=(($137+64)|0);
6079       var $139=HEAP32[(($138)>>2)];
6080       var $140=$st;
6081       var $141=(($140+6)|0);
6082       var $142=$141;
6083       var $143=HEAP16[(($142)>>1)];
6084       var $144=(($143)&65535);
6085       var $145=(($139+($144<<2))|0);
6086       var $146=$145;
6087       var $147=$146;
6088       HEAPF32[(($147)>>2)]=$136;
6089       __label__ = 124; break;
6090     case 11:
6091       var $149=$2;
6092       var $150=(($149+64)|0);
6093       var $151=HEAP32[(($150)>>2)];
6094       var $152=$st;
6095       var $153=(($152+2)|0);
6096       var $154=$153;
6097       var $155=HEAP16[(($154)>>1)];
6098       var $156=(($155)&65535);
6099       var $157=(($151+($156<<2))|0);
6100       var $158=$157;
6101       var $159=$158;
6102       var $160=(($159)|0);
6103       var $161=HEAPF32[(($160)>>2)];
6104       var $162=$2;
6105       var $163=(($162+64)|0);
6106       var $164=HEAP32[(($163)>>2)];
6107       var $165=$st;
6108       var $166=(($165+4)|0);
6109       var $167=$166;
6110       var $168=HEAP16[(($167)>>1)];
6111       var $169=(($168)&65535);
6112       var $170=(($164+($169<<2))|0);
6113       var $171=$170;
6114       var $172=$171;
6115       var $173=(($172)|0);
6116       var $174=HEAPF32[(($173)>>2)];
6117       var $175=($161)*($174);
6118       var $176=$2;
6119       var $177=(($176+64)|0);
6120       var $178=HEAP32[(($177)>>2)];
6121       var $179=$st;
6122       var $180=(($179+2)|0);
6123       var $181=$180;
6124       var $182=HEAP16[(($181)>>1)];
6125       var $183=(($182)&65535);
6126       var $184=(($178+($183<<2))|0);
6127       var $185=$184;
6128       var $186=$185;
6129       var $187=(($186+4)|0);
6130       var $188=HEAPF32[(($187)>>2)];
6131       var $189=$2;
6132       var $190=(($189+64)|0);
6133       var $191=HEAP32[(($190)>>2)];
6134       var $192=$st;
6135       var $193=(($192+4)|0);
6136       var $194=$193;
6137       var $195=HEAP16[(($194)>>1)];
6138       var $196=(($195)&65535);
6139       var $197=(($191+($196<<2))|0);
6140       var $198=$197;
6141       var $199=$198;
6142       var $200=(($199+4)|0);
6143       var $201=HEAPF32[(($200)>>2)];
6144       var $202=($188)*($201);
6145       var $203=($175)+($202);
6146       var $204=$2;
6147       var $205=(($204+64)|0);
6148       var $206=HEAP32[(($205)>>2)];
6149       var $207=$st;
6150       var $208=(($207+2)|0);
6151       var $209=$208;
6152       var $210=HEAP16[(($209)>>1)];
6153       var $211=(($210)&65535);
6154       var $212=(($206+($211<<2))|0);
6155       var $213=$212;
6156       var $214=$213;
6157       var $215=(($214+8)|0);
6158       var $216=HEAPF32[(($215)>>2)];
6159       var $217=$2;
6160       var $218=(($217+64)|0);
6161       var $219=HEAP32[(($218)>>2)];
6162       var $220=$st;
6163       var $221=(($220+4)|0);
6164       var $222=$221;
6165       var $223=HEAP16[(($222)>>1)];
6166       var $224=(($223)&65535);
6167       var $225=(($219+($224<<2))|0);
6168       var $226=$225;
6169       var $227=$226;
6170       var $228=(($227+8)|0);
6171       var $229=HEAPF32[(($228)>>2)];
6172       var $230=($216)*($229);
6173       var $231=($203)+($230);
6174       var $232=$2;
6175       var $233=(($232+64)|0);
6176       var $234=HEAP32[(($233)>>2)];
6177       var $235=$st;
6178       var $236=(($235+6)|0);
6179       var $237=$236;
6180       var $238=HEAP16[(($237)>>1)];
6181       var $239=(($238)&65535);
6182       var $240=(($234+($239<<2))|0);
6183       var $241=$240;
6184       var $242=$241;
6185       HEAPF32[(($242)>>2)]=$231;
6186       __label__ = 124; break;
6187     case 12:
6188       var $244=$2;
6189       var $245=(($244+64)|0);
6190       var $246=HEAP32[(($245)>>2)];
6191       var $247=$st;
6192       var $248=(($247+2)|0);
6193       var $249=$248;
6194       var $250=HEAP16[(($249)>>1)];
6195       var $251=(($250)&65535);
6196       var $252=(($246+($251<<2))|0);
6197       var $253=$252;
6198       var $254=$253;
6199       var $255=HEAPF32[(($254)>>2)];
6200       var $256=$2;
6201       var $257=(($256+64)|0);
6202       var $258=HEAP32[(($257)>>2)];
6203       var $259=$st;
6204       var $260=(($259+4)|0);
6205       var $261=$260;
6206       var $262=HEAP16[(($261)>>1)];
6207       var $263=(($262)&65535);
6208       var $264=(($258+($263<<2))|0);
6209       var $265=$264;
6210       var $266=$265;
6211       var $267=(($266)|0);
6212       var $268=HEAPF32[(($267)>>2)];
6213       var $269=($255)*($268);
6214       var $270=$2;
6215       var $271=(($270+64)|0);
6216       var $272=HEAP32[(($271)>>2)];
6217       var $273=$st;
6218       var $274=(($273+6)|0);
6219       var $275=$274;
6220       var $276=HEAP16[(($275)>>1)];
6221       var $277=(($276)&65535);
6222       var $278=(($272+($277<<2))|0);
6223       var $279=$278;
6224       var $280=$279;
6225       var $281=(($280)|0);
6226       HEAPF32[(($281)>>2)]=$269;
6227       var $282=$2;
6228       var $283=(($282+64)|0);
6229       var $284=HEAP32[(($283)>>2)];
6230       var $285=$st;
6231       var $286=(($285+2)|0);
6232       var $287=$286;
6233       var $288=HEAP16[(($287)>>1)];
6234       var $289=(($288)&65535);
6235       var $290=(($284+($289<<2))|0);
6236       var $291=$290;
6237       var $292=$291;
6238       var $293=HEAPF32[(($292)>>2)];
6239       var $294=$2;
6240       var $295=(($294+64)|0);
6241       var $296=HEAP32[(($295)>>2)];
6242       var $297=$st;
6243       var $298=(($297+4)|0);
6244       var $299=$298;
6245       var $300=HEAP16[(($299)>>1)];
6246       var $301=(($300)&65535);
6247       var $302=(($296+($301<<2))|0);
6248       var $303=$302;
6249       var $304=$303;
6250       var $305=(($304+4)|0);
6251       var $306=HEAPF32[(($305)>>2)];
6252       var $307=($293)*($306);
6253       var $308=$2;
6254       var $309=(($308+64)|0);
6255       var $310=HEAP32[(($309)>>2)];
6256       var $311=$st;
6257       var $312=(($311+6)|0);
6258       var $313=$312;
6259       var $314=HEAP16[(($313)>>1)];
6260       var $315=(($314)&65535);
6261       var $316=(($310+($315<<2))|0);
6262       var $317=$316;
6263       var $318=$317;
6264       var $319=(($318+4)|0);
6265       HEAPF32[(($319)>>2)]=$307;
6266       var $320=$2;
6267       var $321=(($320+64)|0);
6268       var $322=HEAP32[(($321)>>2)];
6269       var $323=$st;
6270       var $324=(($323+2)|0);
6271       var $325=$324;
6272       var $326=HEAP16[(($325)>>1)];
6273       var $327=(($326)&65535);
6274       var $328=(($322+($327<<2))|0);
6275       var $329=$328;
6276       var $330=$329;
6277       var $331=HEAPF32[(($330)>>2)];
6278       var $332=$2;
6279       var $333=(($332+64)|0);
6280       var $334=HEAP32[(($333)>>2)];
6281       var $335=$st;
6282       var $336=(($335+4)|0);
6283       var $337=$336;
6284       var $338=HEAP16[(($337)>>1)];
6285       var $339=(($338)&65535);
6286       var $340=(($334+($339<<2))|0);
6287       var $341=$340;
6288       var $342=$341;
6289       var $343=(($342+8)|0);
6290       var $344=HEAPF32[(($343)>>2)];
6291       var $345=($331)*($344);
6292       var $346=$2;
6293       var $347=(($346+64)|0);
6294       var $348=HEAP32[(($347)>>2)];
6295       var $349=$st;
6296       var $350=(($349+6)|0);
6297       var $351=$350;
6298       var $352=HEAP16[(($351)>>1)];
6299       var $353=(($352)&65535);
6300       var $354=(($348+($353<<2))|0);
6301       var $355=$354;
6302       var $356=$355;
6303       var $357=(($356+8)|0);
6304       HEAPF32[(($357)>>2)]=$345;
6305       __label__ = 124; break;
6306     case 13:
6307       var $359=$2;
6308       var $360=(($359+64)|0);
6309       var $361=HEAP32[(($360)>>2)];
6310       var $362=$st;
6311       var $363=(($362+4)|0);
6312       var $364=$363;
6313       var $365=HEAP16[(($364)>>1)];
6314       var $366=(($365)&65535);
6315       var $367=(($361+($366<<2))|0);
6316       var $368=$367;
6317       var $369=$368;
6318       var $370=HEAPF32[(($369)>>2)];
6319       var $371=$2;
6320       var $372=(($371+64)|0);
6321       var $373=HEAP32[(($372)>>2)];
6322       var $374=$st;
6323       var $375=(($374+2)|0);
6324       var $376=$375;
6325       var $377=HEAP16[(($376)>>1)];
6326       var $378=(($377)&65535);
6327       var $379=(($373+($378<<2))|0);
6328       var $380=$379;
6329       var $381=$380;
6330       var $382=(($381)|0);
6331       var $383=HEAPF32[(($382)>>2)];
6332       var $384=($370)*($383);
6333       var $385=$2;
6334       var $386=(($385+64)|0);
6335       var $387=HEAP32[(($386)>>2)];
6336       var $388=$st;
6337       var $389=(($388+6)|0);
6338       var $390=$389;
6339       var $391=HEAP16[(($390)>>1)];
6340       var $392=(($391)&65535);
6341       var $393=(($387+($392<<2))|0);
6342       var $394=$393;
6343       var $395=$394;
6344       var $396=(($395)|0);
6345       HEAPF32[(($396)>>2)]=$384;
6346       var $397=$2;
6347       var $398=(($397+64)|0);
6348       var $399=HEAP32[(($398)>>2)];
6349       var $400=$st;
6350       var $401=(($400+4)|0);
6351       var $402=$401;
6352       var $403=HEAP16[(($402)>>1)];
6353       var $404=(($403)&65535);
6354       var $405=(($399+($404<<2))|0);
6355       var $406=$405;
6356       var $407=$406;
6357       var $408=HEAPF32[(($407)>>2)];
6358       var $409=$2;
6359       var $410=(($409+64)|0);
6360       var $411=HEAP32[(($410)>>2)];
6361       var $412=$st;
6362       var $413=(($412+2)|0);
6363       var $414=$413;
6364       var $415=HEAP16[(($414)>>1)];
6365       var $416=(($415)&65535);
6366       var $417=(($411+($416<<2))|0);
6367       var $418=$417;
6368       var $419=$418;
6369       var $420=(($419+4)|0);
6370       var $421=HEAPF32[(($420)>>2)];
6371       var $422=($408)*($421);
6372       var $423=$2;
6373       var $424=(($423+64)|0);
6374       var $425=HEAP32[(($424)>>2)];
6375       var $426=$st;
6376       var $427=(($426+6)|0);
6377       var $428=$427;
6378       var $429=HEAP16[(($428)>>1)];
6379       var $430=(($429)&65535);
6380       var $431=(($425+($430<<2))|0);
6381       var $432=$431;
6382       var $433=$432;
6383       var $434=(($433+4)|0);
6384       HEAPF32[(($434)>>2)]=$422;
6385       var $435=$2;
6386       var $436=(($435+64)|0);
6387       var $437=HEAP32[(($436)>>2)];
6388       var $438=$st;
6389       var $439=(($438+4)|0);
6390       var $440=$439;
6391       var $441=HEAP16[(($440)>>1)];
6392       var $442=(($441)&65535);
6393       var $443=(($437+($442<<2))|0);
6394       var $444=$443;
6395       var $445=$444;
6396       var $446=HEAPF32[(($445)>>2)];
6397       var $447=$2;
6398       var $448=(($447+64)|0);
6399       var $449=HEAP32[(($448)>>2)];
6400       var $450=$st;
6401       var $451=(($450+2)|0);
6402       var $452=$451;
6403       var $453=HEAP16[(($452)>>1)];
6404       var $454=(($453)&65535);
6405       var $455=(($449+($454<<2))|0);
6406       var $456=$455;
6407       var $457=$456;
6408       var $458=(($457+8)|0);
6409       var $459=HEAPF32[(($458)>>2)];
6410       var $460=($446)*($459);
6411       var $461=$2;
6412       var $462=(($461+64)|0);
6413       var $463=HEAP32[(($462)>>2)];
6414       var $464=$st;
6415       var $465=(($464+6)|0);
6416       var $466=$465;
6417       var $467=HEAP16[(($466)>>1)];
6418       var $468=(($467)&65535);
6419       var $469=(($463+($468<<2))|0);
6420       var $470=$469;
6421       var $471=$470;
6422       var $472=(($471+8)|0);
6423       HEAPF32[(($472)>>2)]=$460;
6424       __label__ = 124; break;
6425     case 14:
6426       var $474=$2;
6427       var $475=(($474+64)|0);
6428       var $476=HEAP32[(($475)>>2)];
6429       var $477=$st;
6430       var $478=(($477+4)|0);
6431       var $479=$478;
6432       var $480=HEAP16[(($479)>>1)];
6433       var $481=(($480)&65535);
6434       var $482=(($476+($481<<2))|0);
6435       var $483=$482;
6436       var $484=$483;
6437       var $485=HEAPF32[(($484)>>2)];
6438       var $486=$485 != 0;
6439       if ($486) { __label__ = 15; break; } else { __label__ = 16; break; }
6440     case 15:
6441       var $488=$2;
6442       var $489=(($488+64)|0);
6443       var $490=HEAP32[(($489)>>2)];
6444       var $491=$st;
6445       var $492=(($491+2)|0);
6446       var $493=$492;
6447       var $494=HEAP16[(($493)>>1)];
6448       var $495=(($494)&65535);
6449       var $496=(($490+($495<<2))|0);
6450       var $497=$496;
6451       var $498=$497;
6452       var $499=HEAPF32[(($498)>>2)];
6453       var $500=$2;
6454       var $501=(($500+64)|0);
6455       var $502=HEAP32[(($501)>>2)];
6456       var $503=$st;
6457       var $504=(($503+4)|0);
6458       var $505=$504;
6459       var $506=HEAP16[(($505)>>1)];
6460       var $507=(($506)&65535);
6461       var $508=(($502+($507<<2))|0);
6462       var $509=$508;
6463       var $510=$509;
6464       var $511=HEAPF32[(($510)>>2)];
6465       var $512=($499)/($511);
6466       var $513=$2;
6467       var $514=(($513+64)|0);
6468       var $515=HEAP32[(($514)>>2)];
6469       var $516=$st;
6470       var $517=(($516+6)|0);
6471       var $518=$517;
6472       var $519=HEAP16[(($518)>>1)];
6473       var $520=(($519)&65535);
6474       var $521=(($515+($520<<2))|0);
6475       var $522=$521;
6476       var $523=$522;
6477       HEAPF32[(($523)>>2)]=$512;
6478       __label__ = 17; break;
6479     case 16:
6480       var $525=$2;
6481       var $526=(($525+64)|0);
6482       var $527=HEAP32[(($526)>>2)];
6483       var $528=$st;
6484       var $529=(($528+6)|0);
6485       var $530=$529;
6486       var $531=HEAP16[(($530)>>1)];
6487       var $532=(($531)&65535);
6488       var $533=(($527+($532<<2))|0);
6489       var $534=$533;
6490       var $535=$534;
6491       HEAPF32[(($535)>>2)]=0;
6492       __label__ = 17; break;
6493     case 17:
6494       __label__ = 124; break;
6495     case 18:
6496       var $538=$2;
6497       var $539=(($538+64)|0);
6498       var $540=HEAP32[(($539)>>2)];
6499       var $541=$st;
6500       var $542=(($541+2)|0);
6501       var $543=$542;
6502       var $544=HEAP16[(($543)>>1)];
6503       var $545=(($544)&65535);
6504       var $546=(($540+($545<<2))|0);
6505       var $547=$546;
6506       var $548=$547;
6507       var $549=HEAPF32[(($548)>>2)];
6508       var $550=$2;
6509       var $551=(($550+64)|0);
6510       var $552=HEAP32[(($551)>>2)];
6511       var $553=$st;
6512       var $554=(($553+4)|0);
6513       var $555=$554;
6514       var $556=HEAP16[(($555)>>1)];
6515       var $557=(($556)&65535);
6516       var $558=(($552+($557<<2))|0);
6517       var $559=$558;
6518       var $560=$559;
6519       var $561=HEAPF32[(($560)>>2)];
6520       var $562=($549)+($561);
6521       var $563=$2;
6522       var $564=(($563+64)|0);
6523       var $565=HEAP32[(($564)>>2)];
6524       var $566=$st;
6525       var $567=(($566+6)|0);
6526       var $568=$567;
6527       var $569=HEAP16[(($568)>>1)];
6528       var $570=(($569)&65535);
6529       var $571=(($565+($570<<2))|0);
6530       var $572=$571;
6531       var $573=$572;
6532       HEAPF32[(($573)>>2)]=$562;
6533       __label__ = 124; break;
6534     case 19:
6535       var $575=$2;
6536       var $576=(($575+64)|0);
6537       var $577=HEAP32[(($576)>>2)];
6538       var $578=$st;
6539       var $579=(($578+2)|0);
6540       var $580=$579;
6541       var $581=HEAP16[(($580)>>1)];
6542       var $582=(($581)&65535);
6543       var $583=(($577+($582<<2))|0);
6544       var $584=$583;
6545       var $585=$584;
6546       var $586=(($585)|0);
6547       var $587=HEAPF32[(($586)>>2)];
6548       var $588=$2;
6549       var $589=(($588+64)|0);
6550       var $590=HEAP32[(($589)>>2)];
6551       var $591=$st;
6552       var $592=(($591+4)|0);
6553       var $593=$592;
6554       var $594=HEAP16[(($593)>>1)];
6555       var $595=(($594)&65535);
6556       var $596=(($590+($595<<2))|0);
6557       var $597=$596;
6558       var $598=$597;
6559       var $599=(($598)|0);
6560       var $600=HEAPF32[(($599)>>2)];
6561       var $601=($587)+($600);
6562       var $602=$2;
6563       var $603=(($602+64)|0);
6564       var $604=HEAP32[(($603)>>2)];
6565       var $605=$st;
6566       var $606=(($605+6)|0);
6567       var $607=$606;
6568       var $608=HEAP16[(($607)>>1)];
6569       var $609=(($608)&65535);
6570       var $610=(($604+($609<<2))|0);
6571       var $611=$610;
6572       var $612=$611;
6573       var $613=(($612)|0);
6574       HEAPF32[(($613)>>2)]=$601;
6575       var $614=$2;
6576       var $615=(($614+64)|0);
6577       var $616=HEAP32[(($615)>>2)];
6578       var $617=$st;
6579       var $618=(($617+2)|0);
6580       var $619=$618;
6581       var $620=HEAP16[(($619)>>1)];
6582       var $621=(($620)&65535);
6583       var $622=(($616+($621<<2))|0);
6584       var $623=$622;
6585       var $624=$623;
6586       var $625=(($624+4)|0);
6587       var $626=HEAPF32[(($625)>>2)];
6588       var $627=$2;
6589       var $628=(($627+64)|0);
6590       var $629=HEAP32[(($628)>>2)];
6591       var $630=$st;
6592       var $631=(($630+4)|0);
6593       var $632=$631;
6594       var $633=HEAP16[(($632)>>1)];
6595       var $634=(($633)&65535);
6596       var $635=(($629+($634<<2))|0);
6597       var $636=$635;
6598       var $637=$636;
6599       var $638=(($637+4)|0);
6600       var $639=HEAPF32[(($638)>>2)];
6601       var $640=($626)+($639);
6602       var $641=$2;
6603       var $642=(($641+64)|0);
6604       var $643=HEAP32[(($642)>>2)];
6605       var $644=$st;
6606       var $645=(($644+6)|0);
6607       var $646=$645;
6608       var $647=HEAP16[(($646)>>1)];
6609       var $648=(($647)&65535);
6610       var $649=(($643+($648<<2))|0);
6611       var $650=$649;
6612       var $651=$650;
6613       var $652=(($651+4)|0);
6614       HEAPF32[(($652)>>2)]=$640;
6615       var $653=$2;
6616       var $654=(($653+64)|0);
6617       var $655=HEAP32[(($654)>>2)];
6618       var $656=$st;
6619       var $657=(($656+2)|0);
6620       var $658=$657;
6621       var $659=HEAP16[(($658)>>1)];
6622       var $660=(($659)&65535);
6623       var $661=(($655+($660<<2))|0);
6624       var $662=$661;
6625       var $663=$662;
6626       var $664=(($663+8)|0);
6627       var $665=HEAPF32[(($664)>>2)];
6628       var $666=$2;
6629       var $667=(($666+64)|0);
6630       var $668=HEAP32[(($667)>>2)];
6631       var $669=$st;
6632       var $670=(($669+4)|0);
6633       var $671=$670;
6634       var $672=HEAP16[(($671)>>1)];
6635       var $673=(($672)&65535);
6636       var $674=(($668+($673<<2))|0);
6637       var $675=$674;
6638       var $676=$675;
6639       var $677=(($676+8)|0);
6640       var $678=HEAPF32[(($677)>>2)];
6641       var $679=($665)+($678);
6642       var $680=$2;
6643       var $681=(($680+64)|0);
6644       var $682=HEAP32[(($681)>>2)];
6645       var $683=$st;
6646       var $684=(($683+6)|0);
6647       var $685=$684;
6648       var $686=HEAP16[(($685)>>1)];
6649       var $687=(($686)&65535);
6650       var $688=(($682+($687<<2))|0);
6651       var $689=$688;
6652       var $690=$689;
6653       var $691=(($690+8)|0);
6654       HEAPF32[(($691)>>2)]=$679;
6655       __label__ = 124; break;
6656     case 20:
6657       var $693=$2;
6658       var $694=(($693+64)|0);
6659       var $695=HEAP32[(($694)>>2)];
6660       var $696=$st;
6661       var $697=(($696+2)|0);
6662       var $698=$697;
6663       var $699=HEAP16[(($698)>>1)];
6664       var $700=(($699)&65535);
6665       var $701=(($695+($700<<2))|0);
6666       var $702=$701;
6667       var $703=$702;
6668       var $704=HEAPF32[(($703)>>2)];
6669       var $705=$2;
6670       var $706=(($705+64)|0);
6671       var $707=HEAP32[(($706)>>2)];
6672       var $708=$st;
6673       var $709=(($708+4)|0);
6674       var $710=$709;
6675       var $711=HEAP16[(($710)>>1)];
6676       var $712=(($711)&65535);
6677       var $713=(($707+($712<<2))|0);
6678       var $714=$713;
6679       var $715=$714;
6680       var $716=HEAPF32[(($715)>>2)];
6681       var $717=($704)-($716);
6682       var $718=$2;
6683       var $719=(($718+64)|0);
6684       var $720=HEAP32[(($719)>>2)];
6685       var $721=$st;
6686       var $722=(($721+6)|0);
6687       var $723=$722;
6688       var $724=HEAP16[(($723)>>1)];
6689       var $725=(($724)&65535);
6690       var $726=(($720+($725<<2))|0);
6691       var $727=$726;
6692       var $728=$727;
6693       HEAPF32[(($728)>>2)]=$717;
6694       __label__ = 124; break;
6695     case 21:
6696       var $730=$2;
6697       var $731=(($730+64)|0);
6698       var $732=HEAP32[(($731)>>2)];
6699       var $733=$st;
6700       var $734=(($733+2)|0);
6701       var $735=$734;
6702       var $736=HEAP16[(($735)>>1)];
6703       var $737=(($736)&65535);
6704       var $738=(($732+($737<<2))|0);
6705       var $739=$738;
6706       var $740=$739;
6707       var $741=(($740)|0);
6708       var $742=HEAPF32[(($741)>>2)];
6709       var $743=$2;
6710       var $744=(($743+64)|0);
6711       var $745=HEAP32[(($744)>>2)];
6712       var $746=$st;
6713       var $747=(($746+4)|0);
6714       var $748=$747;
6715       var $749=HEAP16[(($748)>>1)];
6716       var $750=(($749)&65535);
6717       var $751=(($745+($750<<2))|0);
6718       var $752=$751;
6719       var $753=$752;
6720       var $754=(($753)|0);
6721       var $755=HEAPF32[(($754)>>2)];
6722       var $756=($742)-($755);
6723       var $757=$2;
6724       var $758=(($757+64)|0);
6725       var $759=HEAP32[(($758)>>2)];
6726       var $760=$st;
6727       var $761=(($760+6)|0);
6728       var $762=$761;
6729       var $763=HEAP16[(($762)>>1)];
6730       var $764=(($763)&65535);
6731       var $765=(($759+($764<<2))|0);
6732       var $766=$765;
6733       var $767=$766;
6734       var $768=(($767)|0);
6735       HEAPF32[(($768)>>2)]=$756;
6736       var $769=$2;
6737       var $770=(($769+64)|0);
6738       var $771=HEAP32[(($770)>>2)];
6739       var $772=$st;
6740       var $773=(($772+2)|0);
6741       var $774=$773;
6742       var $775=HEAP16[(($774)>>1)];
6743       var $776=(($775)&65535);
6744       var $777=(($771+($776<<2))|0);
6745       var $778=$777;
6746       var $779=$778;
6747       var $780=(($779+4)|0);
6748       var $781=HEAPF32[(($780)>>2)];
6749       var $782=$2;
6750       var $783=(($782+64)|0);
6751       var $784=HEAP32[(($783)>>2)];
6752       var $785=$st;
6753       var $786=(($785+4)|0);
6754       var $787=$786;
6755       var $788=HEAP16[(($787)>>1)];
6756       var $789=(($788)&65535);
6757       var $790=(($784+($789<<2))|0);
6758       var $791=$790;
6759       var $792=$791;
6760       var $793=(($792+4)|0);
6761       var $794=HEAPF32[(($793)>>2)];
6762       var $795=($781)-($794);
6763       var $796=$2;
6764       var $797=(($796+64)|0);
6765       var $798=HEAP32[(($797)>>2)];
6766       var $799=$st;
6767       var $800=(($799+6)|0);
6768       var $801=$800;
6769       var $802=HEAP16[(($801)>>1)];
6770       var $803=(($802)&65535);
6771       var $804=(($798+($803<<2))|0);
6772       var $805=$804;
6773       var $806=$805;
6774       var $807=(($806+4)|0);
6775       HEAPF32[(($807)>>2)]=$795;
6776       var $808=$2;
6777       var $809=(($808+64)|0);
6778       var $810=HEAP32[(($809)>>2)];
6779       var $811=$st;
6780       var $812=(($811+2)|0);
6781       var $813=$812;
6782       var $814=HEAP16[(($813)>>1)];
6783       var $815=(($814)&65535);
6784       var $816=(($810+($815<<2))|0);
6785       var $817=$816;
6786       var $818=$817;
6787       var $819=(($818+8)|0);
6788       var $820=HEAPF32[(($819)>>2)];
6789       var $821=$2;
6790       var $822=(($821+64)|0);
6791       var $823=HEAP32[(($822)>>2)];
6792       var $824=$st;
6793       var $825=(($824+4)|0);
6794       var $826=$825;
6795       var $827=HEAP16[(($826)>>1)];
6796       var $828=(($827)&65535);
6797       var $829=(($823+($828<<2))|0);
6798       var $830=$829;
6799       var $831=$830;
6800       var $832=(($831+8)|0);
6801       var $833=HEAPF32[(($832)>>2)];
6802       var $834=($820)-($833);
6803       var $835=$2;
6804       var $836=(($835+64)|0);
6805       var $837=HEAP32[(($836)>>2)];
6806       var $838=$st;
6807       var $839=(($838+6)|0);
6808       var $840=$839;
6809       var $841=HEAP16[(($840)>>1)];
6810       var $842=(($841)&65535);
6811       var $843=(($837+($842<<2))|0);
6812       var $844=$843;
6813       var $845=$844;
6814       var $846=(($845+8)|0);
6815       HEAPF32[(($846)>>2)]=$834;
6816       __label__ = 124; break;
6817     case 22:
6818       var $848=$2;
6819       var $849=(($848+64)|0);
6820       var $850=HEAP32[(($849)>>2)];
6821       var $851=$st;
6822       var $852=(($851+2)|0);
6823       var $853=$852;
6824       var $854=HEAP16[(($853)>>1)];
6825       var $855=(($854)&65535);
6826       var $856=(($850+($855<<2))|0);
6827       var $857=$856;
6828       var $858=$857;
6829       var $859=HEAPF32[(($858)>>2)];
6830       var $860=$2;
6831       var $861=(($860+64)|0);
6832       var $862=HEAP32[(($861)>>2)];
6833       var $863=$st;
6834       var $864=(($863+4)|0);
6835       var $865=$864;
6836       var $866=HEAP16[(($865)>>1)];
6837       var $867=(($866)&65535);
6838       var $868=(($862+($867<<2))|0);
6839       var $869=$868;
6840       var $870=$869;
6841       var $871=HEAPF32[(($870)>>2)];
6842       var $872=$859 == $871;
6843       var $873=(($872)&1);
6844       var $874=(($873)|0);
6845       var $875=$2;
6846       var $876=(($875+64)|0);
6847       var $877=HEAP32[(($876)>>2)];
6848       var $878=$st;
6849       var $879=(($878+6)|0);
6850       var $880=$879;
6851       var $881=HEAP16[(($880)>>1)];
6852       var $882=(($881)&65535);
6853       var $883=(($877+($882<<2))|0);
6854       var $884=$883;
6855       var $885=$884;
6856       HEAPF32[(($885)>>2)]=$874;
6857       __label__ = 124; break;
6858     case 23:
6859       var $887=$2;
6860       var $888=(($887+64)|0);
6861       var $889=HEAP32[(($888)>>2)];
6862       var $890=$st;
6863       var $891=(($890+2)|0);
6864       var $892=$891;
6865       var $893=HEAP16[(($892)>>1)];
6866       var $894=(($893)&65535);
6867       var $895=(($889+($894<<2))|0);
6868       var $896=$895;
6869       var $897=$896;
6870       var $898=(($897)|0);
6871       var $899=HEAPF32[(($898)>>2)];
6872       var $900=$2;
6873       var $901=(($900+64)|0);
6874       var $902=HEAP32[(($901)>>2)];
6875       var $903=$st;
6876       var $904=(($903+4)|0);
6877       var $905=$904;
6878       var $906=HEAP16[(($905)>>1)];
6879       var $907=(($906)&65535);
6880       var $908=(($902+($907<<2))|0);
6881       var $909=$908;
6882       var $910=$909;
6883       var $911=(($910)|0);
6884       var $912=HEAPF32[(($911)>>2)];
6885       var $913=$899 == $912;
6886       if ($913) { __label__ = 24; break; } else { var $971 = 0;__label__ = 26; break; }
6887     case 24:
6888       var $915=$2;
6889       var $916=(($915+64)|0);
6890       var $917=HEAP32[(($916)>>2)];
6891       var $918=$st;
6892       var $919=(($918+2)|0);
6893       var $920=$919;
6894       var $921=HEAP16[(($920)>>1)];
6895       var $922=(($921)&65535);
6896       var $923=(($917+($922<<2))|0);
6897       var $924=$923;
6898       var $925=$924;
6899       var $926=(($925+4)|0);
6900       var $927=HEAPF32[(($926)>>2)];
6901       var $928=$2;
6902       var $929=(($928+64)|0);
6903       var $930=HEAP32[(($929)>>2)];
6904       var $931=$st;
6905       var $932=(($931+4)|0);
6906       var $933=$932;
6907       var $934=HEAP16[(($933)>>1)];
6908       var $935=(($934)&65535);
6909       var $936=(($930+($935<<2))|0);
6910       var $937=$936;
6911       var $938=$937;
6912       var $939=(($938+4)|0);
6913       var $940=HEAPF32[(($939)>>2)];
6914       var $941=$927 == $940;
6915       if ($941) { __label__ = 25; break; } else { var $971 = 0;__label__ = 26; break; }
6916     case 25:
6917       var $943=$2;
6918       var $944=(($943+64)|0);
6919       var $945=HEAP32[(($944)>>2)];
6920       var $946=$st;
6921       var $947=(($946+2)|0);
6922       var $948=$947;
6923       var $949=HEAP16[(($948)>>1)];
6924       var $950=(($949)&65535);
6925       var $951=(($945+($950<<2))|0);
6926       var $952=$951;
6927       var $953=$952;
6928       var $954=(($953+8)|0);
6929       var $955=HEAPF32[(($954)>>2)];
6930       var $956=$2;
6931       var $957=(($956+64)|0);
6932       var $958=HEAP32[(($957)>>2)];
6933       var $959=$st;
6934       var $960=(($959+4)|0);
6935       var $961=$960;
6936       var $962=HEAP16[(($961)>>1)];
6937       var $963=(($962)&65535);
6938       var $964=(($958+($963<<2))|0);
6939       var $965=$964;
6940       var $966=$965;
6941       var $967=(($966+8)|0);
6942       var $968=HEAPF32[(($967)>>2)];
6943       var $969=$955 == $968;
6944       var $971 = $969;__label__ = 26; break;
6945     case 26:
6946       var $971;
6947       var $972=(($971)&1);
6948       var $973=(($972)|0);
6949       var $974=$2;
6950       var $975=(($974+64)|0);
6951       var $976=HEAP32[(($975)>>2)];
6952       var $977=$st;
6953       var $978=(($977+6)|0);
6954       var $979=$978;
6955       var $980=HEAP16[(($979)>>1)];
6956       var $981=(($980)&65535);
6957       var $982=(($976+($981<<2))|0);
6958       var $983=$982;
6959       var $984=$983;
6960       HEAPF32[(($984)>>2)]=$973;
6961       __label__ = 124; break;
6962     case 27:
6963       var $986=$2;
6964       var $987=$2;
6965       var $988=(($987+64)|0);
6966       var $989=HEAP32[(($988)>>2)];
6967       var $990=$st;
6968       var $991=(($990+2)|0);
6969       var $992=$991;
6970       var $993=HEAP16[(($992)>>1)];
6971       var $994=(($993)&65535);
6972       var $995=(($989+($994<<2))|0);
6973       var $996=$995;
6974       var $997=$996;
6975       var $998=HEAP32[(($997)>>2)];
6976       var $999=_prog_getstring($986, $998);
6977       var $1000=$2;
6978       var $1001=$2;
6979       var $1002=(($1001+64)|0);
6980       var $1003=HEAP32[(($1002)>>2)];
6981       var $1004=$st;
6982       var $1005=(($1004+4)|0);
6983       var $1006=$1005;
6984       var $1007=HEAP16[(($1006)>>1)];
6985       var $1008=(($1007)&65535);
6986       var $1009=(($1003+($1008<<2))|0);
6987       var $1010=$1009;
6988       var $1011=$1010;
6989       var $1012=HEAP32[(($1011)>>2)];
6990       var $1013=_prog_getstring($1000, $1012);
6991       var $1014=_strcmp($999, $1013);
6992       var $1015=(($1014)|0)!=0;
6993       var $1016=$1015 ^ 1;
6994       var $1017=(($1016)&1);
6995       var $1018=(($1017)|0);
6996       var $1019=$2;
6997       var $1020=(($1019+64)|0);
6998       var $1021=HEAP32[(($1020)>>2)];
6999       var $1022=$st;
7000       var $1023=(($1022+6)|0);
7001       var $1024=$1023;
7002       var $1025=HEAP16[(($1024)>>1)];
7003       var $1026=(($1025)&65535);
7004       var $1027=(($1021+($1026<<2))|0);
7005       var $1028=$1027;
7006       var $1029=$1028;
7007       HEAPF32[(($1029)>>2)]=$1018;
7008       __label__ = 124; break;
7009     case 28:
7010       var $1031=$2;
7011       var $1032=(($1031+64)|0);
7012       var $1033=HEAP32[(($1032)>>2)];
7013       var $1034=$st;
7014       var $1035=(($1034+2)|0);
7015       var $1036=$1035;
7016       var $1037=HEAP16[(($1036)>>1)];
7017       var $1038=(($1037)&65535);
7018       var $1039=(($1033+($1038<<2))|0);
7019       var $1040=$1039;
7020       var $1041=$1040;
7021       var $1042=HEAP32[(($1041)>>2)];
7022       var $1043=$2;
7023       var $1044=(($1043+64)|0);
7024       var $1045=HEAP32[(($1044)>>2)];
7025       var $1046=$st;
7026       var $1047=(($1046+4)|0);
7027       var $1048=$1047;
7028       var $1049=HEAP16[(($1048)>>1)];
7029       var $1050=(($1049)&65535);
7030       var $1051=(($1045+($1050<<2))|0);
7031       var $1052=$1051;
7032       var $1053=$1052;
7033       var $1054=HEAP32[(($1053)>>2)];
7034       var $1055=(($1042)|0)==(($1054)|0);
7035       var $1056=(($1055)&1);
7036       var $1057=(($1056)|0);
7037       var $1058=$2;
7038       var $1059=(($1058+64)|0);
7039       var $1060=HEAP32[(($1059)>>2)];
7040       var $1061=$st;
7041       var $1062=(($1061+6)|0);
7042       var $1063=$1062;
7043       var $1064=HEAP16[(($1063)>>1)];
7044       var $1065=(($1064)&65535);
7045       var $1066=(($1060+($1065<<2))|0);
7046       var $1067=$1066;
7047       var $1068=$1067;
7048       HEAPF32[(($1068)>>2)]=$1057;
7049       __label__ = 124; break;
7050     case 29:
7051       var $1070=$2;
7052       var $1071=(($1070+64)|0);
7053       var $1072=HEAP32[(($1071)>>2)];
7054       var $1073=$st;
7055       var $1074=(($1073+2)|0);
7056       var $1075=$1074;
7057       var $1076=HEAP16[(($1075)>>1)];
7058       var $1077=(($1076)&65535);
7059       var $1078=(($1072+($1077<<2))|0);
7060       var $1079=$1078;
7061       var $1080=$1079;
7062       var $1081=HEAP32[(($1080)>>2)];
7063       var $1082=$2;
7064       var $1083=(($1082+64)|0);
7065       var $1084=HEAP32[(($1083)>>2)];
7066       var $1085=$st;
7067       var $1086=(($1085+4)|0);
7068       var $1087=$1086;
7069       var $1088=HEAP16[(($1087)>>1)];
7070       var $1089=(($1088)&65535);
7071       var $1090=(($1084+($1089<<2))|0);
7072       var $1091=$1090;
7073       var $1092=$1091;
7074       var $1093=HEAP32[(($1092)>>2)];
7075       var $1094=(($1081)|0)==(($1093)|0);
7076       var $1095=(($1094)&1);
7077       var $1096=(($1095)|0);
7078       var $1097=$2;
7079       var $1098=(($1097+64)|0);
7080       var $1099=HEAP32[(($1098)>>2)];
7081       var $1100=$st;
7082       var $1101=(($1100+6)|0);
7083       var $1102=$1101;
7084       var $1103=HEAP16[(($1102)>>1)];
7085       var $1104=(($1103)&65535);
7086       var $1105=(($1099+($1104<<2))|0);
7087       var $1106=$1105;
7088       var $1107=$1106;
7089       HEAPF32[(($1107)>>2)]=$1096;
7090       __label__ = 124; break;
7091     case 30:
7092       var $1109=$2;
7093       var $1110=(($1109+64)|0);
7094       var $1111=HEAP32[(($1110)>>2)];
7095       var $1112=$st;
7096       var $1113=(($1112+2)|0);
7097       var $1114=$1113;
7098       var $1115=HEAP16[(($1114)>>1)];
7099       var $1116=(($1115)&65535);
7100       var $1117=(($1111+($1116<<2))|0);
7101       var $1118=$1117;
7102       var $1119=$1118;
7103       var $1120=HEAPF32[(($1119)>>2)];
7104       var $1121=$2;
7105       var $1122=(($1121+64)|0);
7106       var $1123=HEAP32[(($1122)>>2)];
7107       var $1124=$st;
7108       var $1125=(($1124+4)|0);
7109       var $1126=$1125;
7110       var $1127=HEAP16[(($1126)>>1)];
7111       var $1128=(($1127)&65535);
7112       var $1129=(($1123+($1128<<2))|0);
7113       var $1130=$1129;
7114       var $1131=$1130;
7115       var $1132=HEAPF32[(($1131)>>2)];
7116       var $1133=$1120 != $1132;
7117       var $1134=(($1133)&1);
7118       var $1135=(($1134)|0);
7119       var $1136=$2;
7120       var $1137=(($1136+64)|0);
7121       var $1138=HEAP32[(($1137)>>2)];
7122       var $1139=$st;
7123       var $1140=(($1139+6)|0);
7124       var $1141=$1140;
7125       var $1142=HEAP16[(($1141)>>1)];
7126       var $1143=(($1142)&65535);
7127       var $1144=(($1138+($1143<<2))|0);
7128       var $1145=$1144;
7129       var $1146=$1145;
7130       HEAPF32[(($1146)>>2)]=$1135;
7131       __label__ = 124; break;
7132     case 31:
7133       var $1148=$2;
7134       var $1149=(($1148+64)|0);
7135       var $1150=HEAP32[(($1149)>>2)];
7136       var $1151=$st;
7137       var $1152=(($1151+2)|0);
7138       var $1153=$1152;
7139       var $1154=HEAP16[(($1153)>>1)];
7140       var $1155=(($1154)&65535);
7141       var $1156=(($1150+($1155<<2))|0);
7142       var $1157=$1156;
7143       var $1158=$1157;
7144       var $1159=(($1158)|0);
7145       var $1160=HEAPF32[(($1159)>>2)];
7146       var $1161=$2;
7147       var $1162=(($1161+64)|0);
7148       var $1163=HEAP32[(($1162)>>2)];
7149       var $1164=$st;
7150       var $1165=(($1164+4)|0);
7151       var $1166=$1165;
7152       var $1167=HEAP16[(($1166)>>1)];
7153       var $1168=(($1167)&65535);
7154       var $1169=(($1163+($1168<<2))|0);
7155       var $1170=$1169;
7156       var $1171=$1170;
7157       var $1172=(($1171)|0);
7158       var $1173=HEAPF32[(($1172)>>2)];
7159       var $1174=$1160 != $1173;
7160       if ($1174) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 32; break; }
7161     case 32:
7162       var $1176=$2;
7163       var $1177=(($1176+64)|0);
7164       var $1178=HEAP32[(($1177)>>2)];
7165       var $1179=$st;
7166       var $1180=(($1179+2)|0);
7167       var $1181=$1180;
7168       var $1182=HEAP16[(($1181)>>1)];
7169       var $1183=(($1182)&65535);
7170       var $1184=(($1178+($1183<<2))|0);
7171       var $1185=$1184;
7172       var $1186=$1185;
7173       var $1187=(($1186+4)|0);
7174       var $1188=HEAPF32[(($1187)>>2)];
7175       var $1189=$2;
7176       var $1190=(($1189+64)|0);
7177       var $1191=HEAP32[(($1190)>>2)];
7178       var $1192=$st;
7179       var $1193=(($1192+4)|0);
7180       var $1194=$1193;
7181       var $1195=HEAP16[(($1194)>>1)];
7182       var $1196=(($1195)&65535);
7183       var $1197=(($1191+($1196<<2))|0);
7184       var $1198=$1197;
7185       var $1199=$1198;
7186       var $1200=(($1199+4)|0);
7187       var $1201=HEAPF32[(($1200)>>2)];
7188       var $1202=$1188 != $1201;
7189       if ($1202) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 33; break; }
7190     case 33:
7191       var $1204=$2;
7192       var $1205=(($1204+64)|0);
7193       var $1206=HEAP32[(($1205)>>2)];
7194       var $1207=$st;
7195       var $1208=(($1207+2)|0);
7196       var $1209=$1208;
7197       var $1210=HEAP16[(($1209)>>1)];
7198       var $1211=(($1210)&65535);
7199       var $1212=(($1206+($1211<<2))|0);
7200       var $1213=$1212;
7201       var $1214=$1213;
7202       var $1215=(($1214+8)|0);
7203       var $1216=HEAPF32[(($1215)>>2)];
7204       var $1217=$2;
7205       var $1218=(($1217+64)|0);
7206       var $1219=HEAP32[(($1218)>>2)];
7207       var $1220=$st;
7208       var $1221=(($1220+4)|0);
7209       var $1222=$1221;
7210       var $1223=HEAP16[(($1222)>>1)];
7211       var $1224=(($1223)&65535);
7212       var $1225=(($1219+($1224<<2))|0);
7213       var $1226=$1225;
7214       var $1227=$1226;
7215       var $1228=(($1227+8)|0);
7216       var $1229=HEAPF32[(($1228)>>2)];
7217       var $1230=$1216 != $1229;
7218       var $1232 = $1230;__label__ = 34; break;
7219     case 34:
7220       var $1232;
7221       var $1233=(($1232)&1);
7222       var $1234=(($1233)|0);
7223       var $1235=$2;
7224       var $1236=(($1235+64)|0);
7225       var $1237=HEAP32[(($1236)>>2)];
7226       var $1238=$st;
7227       var $1239=(($1238+6)|0);
7228       var $1240=$1239;
7229       var $1241=HEAP16[(($1240)>>1)];
7230       var $1242=(($1241)&65535);
7231       var $1243=(($1237+($1242<<2))|0);
7232       var $1244=$1243;
7233       var $1245=$1244;
7234       HEAPF32[(($1245)>>2)]=$1234;
7235       __label__ = 124; break;
7236     case 35:
7237       var $1247=$2;
7238       var $1248=$2;
7239       var $1249=(($1248+64)|0);
7240       var $1250=HEAP32[(($1249)>>2)];
7241       var $1251=$st;
7242       var $1252=(($1251+2)|0);
7243       var $1253=$1252;
7244       var $1254=HEAP16[(($1253)>>1)];
7245       var $1255=(($1254)&65535);
7246       var $1256=(($1250+($1255<<2))|0);
7247       var $1257=$1256;
7248       var $1258=$1257;
7249       var $1259=HEAP32[(($1258)>>2)];
7250       var $1260=_prog_getstring($1247, $1259);
7251       var $1261=$2;
7252       var $1262=$2;
7253       var $1263=(($1262+64)|0);
7254       var $1264=HEAP32[(($1263)>>2)];
7255       var $1265=$st;
7256       var $1266=(($1265+4)|0);
7257       var $1267=$1266;
7258       var $1268=HEAP16[(($1267)>>1)];
7259       var $1269=(($1268)&65535);
7260       var $1270=(($1264+($1269<<2))|0);
7261       var $1271=$1270;
7262       var $1272=$1271;
7263       var $1273=HEAP32[(($1272)>>2)];
7264       var $1274=_prog_getstring($1261, $1273);
7265       var $1275=_strcmp($1260, $1274);
7266       var $1276=(($1275)|0)!=0;
7267       var $1277=$1276 ^ 1;
7268       var $1278=$1277 ^ 1;
7269       var $1279=(($1278)&1);
7270       var $1280=(($1279)|0);
7271       var $1281=$2;
7272       var $1282=(($1281+64)|0);
7273       var $1283=HEAP32[(($1282)>>2)];
7274       var $1284=$st;
7275       var $1285=(($1284+6)|0);
7276       var $1286=$1285;
7277       var $1287=HEAP16[(($1286)>>1)];
7278       var $1288=(($1287)&65535);
7279       var $1289=(($1283+($1288<<2))|0);
7280       var $1290=$1289;
7281       var $1291=$1290;
7282       HEAPF32[(($1291)>>2)]=$1280;
7283       __label__ = 124; break;
7284     case 36:
7285       var $1293=$2;
7286       var $1294=(($1293+64)|0);
7287       var $1295=HEAP32[(($1294)>>2)];
7288       var $1296=$st;
7289       var $1297=(($1296+2)|0);
7290       var $1298=$1297;
7291       var $1299=HEAP16[(($1298)>>1)];
7292       var $1300=(($1299)&65535);
7293       var $1301=(($1295+($1300<<2))|0);
7294       var $1302=$1301;
7295       var $1303=$1302;
7296       var $1304=HEAP32[(($1303)>>2)];
7297       var $1305=$2;
7298       var $1306=(($1305+64)|0);
7299       var $1307=HEAP32[(($1306)>>2)];
7300       var $1308=$st;
7301       var $1309=(($1308+4)|0);
7302       var $1310=$1309;
7303       var $1311=HEAP16[(($1310)>>1)];
7304       var $1312=(($1311)&65535);
7305       var $1313=(($1307+($1312<<2))|0);
7306       var $1314=$1313;
7307       var $1315=$1314;
7308       var $1316=HEAP32[(($1315)>>2)];
7309       var $1317=(($1304)|0)!=(($1316)|0);
7310       var $1318=(($1317)&1);
7311       var $1319=(($1318)|0);
7312       var $1320=$2;
7313       var $1321=(($1320+64)|0);
7314       var $1322=HEAP32[(($1321)>>2)];
7315       var $1323=$st;
7316       var $1324=(($1323+6)|0);
7317       var $1325=$1324;
7318       var $1326=HEAP16[(($1325)>>1)];
7319       var $1327=(($1326)&65535);
7320       var $1328=(($1322+($1327<<2))|0);
7321       var $1329=$1328;
7322       var $1330=$1329;
7323       HEAPF32[(($1330)>>2)]=$1319;
7324       __label__ = 124; break;
7325     case 37:
7326       var $1332=$2;
7327       var $1333=(($1332+64)|0);
7328       var $1334=HEAP32[(($1333)>>2)];
7329       var $1335=$st;
7330       var $1336=(($1335+2)|0);
7331       var $1337=$1336;
7332       var $1338=HEAP16[(($1337)>>1)];
7333       var $1339=(($1338)&65535);
7334       var $1340=(($1334+($1339<<2))|0);
7335       var $1341=$1340;
7336       var $1342=$1341;
7337       var $1343=HEAP32[(($1342)>>2)];
7338       var $1344=$2;
7339       var $1345=(($1344+64)|0);
7340       var $1346=HEAP32[(($1345)>>2)];
7341       var $1347=$st;
7342       var $1348=(($1347+4)|0);
7343       var $1349=$1348;
7344       var $1350=HEAP16[(($1349)>>1)];
7345       var $1351=(($1350)&65535);
7346       var $1352=(($1346+($1351<<2))|0);
7347       var $1353=$1352;
7348       var $1354=$1353;
7349       var $1355=HEAP32[(($1354)>>2)];
7350       var $1356=(($1343)|0)!=(($1355)|0);
7351       var $1357=(($1356)&1);
7352       var $1358=(($1357)|0);
7353       var $1359=$2;
7354       var $1360=(($1359+64)|0);
7355       var $1361=HEAP32[(($1360)>>2)];
7356       var $1362=$st;
7357       var $1363=(($1362+6)|0);
7358       var $1364=$1363;
7359       var $1365=HEAP16[(($1364)>>1)];
7360       var $1366=(($1365)&65535);
7361       var $1367=(($1361+($1366<<2))|0);
7362       var $1368=$1367;
7363       var $1369=$1368;
7364       HEAPF32[(($1369)>>2)]=$1358;
7365       __label__ = 124; break;
7366     case 38:
7367       var $1371=$2;
7368       var $1372=(($1371+64)|0);
7369       var $1373=HEAP32[(($1372)>>2)];
7370       var $1374=$st;
7371       var $1375=(($1374+2)|0);
7372       var $1376=$1375;
7373       var $1377=HEAP16[(($1376)>>1)];
7374       var $1378=(($1377)&65535);
7375       var $1379=(($1373+($1378<<2))|0);
7376       var $1380=$1379;
7377       var $1381=$1380;
7378       var $1382=HEAPF32[(($1381)>>2)];
7379       var $1383=$2;
7380       var $1384=(($1383+64)|0);
7381       var $1385=HEAP32[(($1384)>>2)];
7382       var $1386=$st;
7383       var $1387=(($1386+4)|0);
7384       var $1388=$1387;
7385       var $1389=HEAP16[(($1388)>>1)];
7386       var $1390=(($1389)&65535);
7387       var $1391=(($1385+($1390<<2))|0);
7388       var $1392=$1391;
7389       var $1393=$1392;
7390       var $1394=HEAPF32[(($1393)>>2)];
7391       var $1395=$1382 <= $1394;
7392       var $1396=(($1395)&1);
7393       var $1397=(($1396)|0);
7394       var $1398=$2;
7395       var $1399=(($1398+64)|0);
7396       var $1400=HEAP32[(($1399)>>2)];
7397       var $1401=$st;
7398       var $1402=(($1401+6)|0);
7399       var $1403=$1402;
7400       var $1404=HEAP16[(($1403)>>1)];
7401       var $1405=(($1404)&65535);
7402       var $1406=(($1400+($1405<<2))|0);
7403       var $1407=$1406;
7404       var $1408=$1407;
7405       HEAPF32[(($1408)>>2)]=$1397;
7406       __label__ = 124; break;
7407     case 39:
7408       var $1410=$2;
7409       var $1411=(($1410+64)|0);
7410       var $1412=HEAP32[(($1411)>>2)];
7411       var $1413=$st;
7412       var $1414=(($1413+2)|0);
7413       var $1415=$1414;
7414       var $1416=HEAP16[(($1415)>>1)];
7415       var $1417=(($1416)&65535);
7416       var $1418=(($1412+($1417<<2))|0);
7417       var $1419=$1418;
7418       var $1420=$1419;
7419       var $1421=HEAPF32[(($1420)>>2)];
7420       var $1422=$2;
7421       var $1423=(($1422+64)|0);
7422       var $1424=HEAP32[(($1423)>>2)];
7423       var $1425=$st;
7424       var $1426=(($1425+4)|0);
7425       var $1427=$1426;
7426       var $1428=HEAP16[(($1427)>>1)];
7427       var $1429=(($1428)&65535);
7428       var $1430=(($1424+($1429<<2))|0);
7429       var $1431=$1430;
7430       var $1432=$1431;
7431       var $1433=HEAPF32[(($1432)>>2)];
7432       var $1434=$1421 >= $1433;
7433       var $1435=(($1434)&1);
7434       var $1436=(($1435)|0);
7435       var $1437=$2;
7436       var $1438=(($1437+64)|0);
7437       var $1439=HEAP32[(($1438)>>2)];
7438       var $1440=$st;
7439       var $1441=(($1440+6)|0);
7440       var $1442=$1441;
7441       var $1443=HEAP16[(($1442)>>1)];
7442       var $1444=(($1443)&65535);
7443       var $1445=(($1439+($1444<<2))|0);
7444       var $1446=$1445;
7445       var $1447=$1446;
7446       HEAPF32[(($1447)>>2)]=$1436;
7447       __label__ = 124; break;
7448     case 40:
7449       var $1449=$2;
7450       var $1450=(($1449+64)|0);
7451       var $1451=HEAP32[(($1450)>>2)];
7452       var $1452=$st;
7453       var $1453=(($1452+2)|0);
7454       var $1454=$1453;
7455       var $1455=HEAP16[(($1454)>>1)];
7456       var $1456=(($1455)&65535);
7457       var $1457=(($1451+($1456<<2))|0);
7458       var $1458=$1457;
7459       var $1459=$1458;
7460       var $1460=HEAPF32[(($1459)>>2)];
7461       var $1461=$2;
7462       var $1462=(($1461+64)|0);
7463       var $1463=HEAP32[(($1462)>>2)];
7464       var $1464=$st;
7465       var $1465=(($1464+4)|0);
7466       var $1466=$1465;
7467       var $1467=HEAP16[(($1466)>>1)];
7468       var $1468=(($1467)&65535);
7469       var $1469=(($1463+($1468<<2))|0);
7470       var $1470=$1469;
7471       var $1471=$1470;
7472       var $1472=HEAPF32[(($1471)>>2)];
7473       var $1473=$1460 < $1472;
7474       var $1474=(($1473)&1);
7475       var $1475=(($1474)|0);
7476       var $1476=$2;
7477       var $1477=(($1476+64)|0);
7478       var $1478=HEAP32[(($1477)>>2)];
7479       var $1479=$st;
7480       var $1480=(($1479+6)|0);
7481       var $1481=$1480;
7482       var $1482=HEAP16[(($1481)>>1)];
7483       var $1483=(($1482)&65535);
7484       var $1484=(($1478+($1483<<2))|0);
7485       var $1485=$1484;
7486       var $1486=$1485;
7487       HEAPF32[(($1486)>>2)]=$1475;
7488       __label__ = 124; break;
7489     case 41:
7490       var $1488=$2;
7491       var $1489=(($1488+64)|0);
7492       var $1490=HEAP32[(($1489)>>2)];
7493       var $1491=$st;
7494       var $1492=(($1491+2)|0);
7495       var $1493=$1492;
7496       var $1494=HEAP16[(($1493)>>1)];
7497       var $1495=(($1494)&65535);
7498       var $1496=(($1490+($1495<<2))|0);
7499       var $1497=$1496;
7500       var $1498=$1497;
7501       var $1499=HEAPF32[(($1498)>>2)];
7502       var $1500=$2;
7503       var $1501=(($1500+64)|0);
7504       var $1502=HEAP32[(($1501)>>2)];
7505       var $1503=$st;
7506       var $1504=(($1503+4)|0);
7507       var $1505=$1504;
7508       var $1506=HEAP16[(($1505)>>1)];
7509       var $1507=(($1506)&65535);
7510       var $1508=(($1502+($1507<<2))|0);
7511       var $1509=$1508;
7512       var $1510=$1509;
7513       var $1511=HEAPF32[(($1510)>>2)];
7514       var $1512=$1499 > $1511;
7515       var $1513=(($1512)&1);
7516       var $1514=(($1513)|0);
7517       var $1515=$2;
7518       var $1516=(($1515+64)|0);
7519       var $1517=HEAP32[(($1516)>>2)];
7520       var $1518=$st;
7521       var $1519=(($1518+6)|0);
7522       var $1520=$1519;
7523       var $1521=HEAP16[(($1520)>>1)];
7524       var $1522=(($1521)&65535);
7525       var $1523=(($1517+($1522<<2))|0);
7526       var $1524=$1523;
7527       var $1525=$1524;
7528       HEAPF32[(($1525)>>2)]=$1514;
7529       __label__ = 124; break;
7530     case 42:
7531       var $1527=$2;
7532       var $1528=(($1527+64)|0);
7533       var $1529=HEAP32[(($1528)>>2)];
7534       var $1530=$st;
7535       var $1531=(($1530+2)|0);
7536       var $1532=$1531;
7537       var $1533=HEAP16[(($1532)>>1)];
7538       var $1534=(($1533)&65535);
7539       var $1535=(($1529+($1534<<2))|0);
7540       var $1536=$1535;
7541       var $1537=$1536;
7542       var $1538=HEAP32[(($1537)>>2)];
7543       var $1539=(($1538)|0) < 0;
7544       if ($1539) { __label__ = 44; break; } else { __label__ = 43; break; }
7545     case 43:
7546       var $1541=$2;
7547       var $1542=(($1541+64)|0);
7548       var $1543=HEAP32[(($1542)>>2)];
7549       var $1544=$st;
7550       var $1545=(($1544+2)|0);
7551       var $1546=$1545;
7552       var $1547=HEAP16[(($1546)>>1)];
7553       var $1548=(($1547)&65535);
7554       var $1549=(($1543+($1548<<2))|0);
7555       var $1550=$1549;
7556       var $1551=$1550;
7557       var $1552=HEAP32[(($1551)>>2)];
7558       var $1553=$2;
7559       var $1554=(($1553+140)|0);
7560       var $1555=HEAP32[(($1554)>>2)];
7561       var $1556=(($1552)|0) >= (($1555)|0);
7562       if ($1556) { __label__ = 44; break; } else { __label__ = 45; break; }
7563     case 44:
7564       var $1558=$2;
7565       var $1559=$2;
7566       var $1560=(($1559)|0);
7567       var $1561=HEAP32[(($1560)>>2)];
7568       _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));
7569       __label__ = 488; break;
7570     case 45:
7571       var $1563=$2;
7572       var $1564=(($1563+64)|0);
7573       var $1565=HEAP32[(($1564)>>2)];
7574       var $1566=$st;
7575       var $1567=(($1566+4)|0);
7576       var $1568=$1567;
7577       var $1569=HEAP16[(($1568)>>1)];
7578       var $1570=(($1569)&65535);
7579       var $1571=(($1565+($1570<<2))|0);
7580       var $1572=$1571;
7581       var $1573=$1572;
7582       var $1574=HEAP32[(($1573)>>2)];
7583       var $1575=$2;
7584       var $1576=(($1575+144)|0);
7585       var $1577=HEAP32[(($1576)>>2)];
7586       var $1578=(($1574)>>>0) >= (($1577)>>>0);
7587       if ($1578) { __label__ = 46; break; } else { __label__ = 47; break; }
7588     case 46:
7589       var $1580=$2;
7590       var $1581=$2;
7591       var $1582=(($1581)|0);
7592       var $1583=HEAP32[(($1582)>>2)];
7593       var $1584=$2;
7594       var $1585=(($1584+64)|0);
7595       var $1586=HEAP32[(($1585)>>2)];
7596       var $1587=$st;
7597       var $1588=(($1587+4)|0);
7598       var $1589=$1588;
7599       var $1590=HEAP16[(($1589)>>1)];
7600       var $1591=(($1590)&65535);
7601       var $1592=(($1586+($1591<<2))|0);
7602       var $1593=$1592;
7603       var $1594=$1593;
7604       var $1595=HEAP32[(($1594)>>2)];
7605       _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));
7606       __label__ = 488; break;
7607     case 47:
7608       var $1597=$2;
7609       var $1598=$2;
7610       var $1599=(($1598+64)|0);
7611       var $1600=HEAP32[(($1599)>>2)];
7612       var $1601=$st;
7613       var $1602=(($1601+2)|0);
7614       var $1603=$1602;
7615       var $1604=HEAP16[(($1603)>>1)];
7616       var $1605=(($1604)&65535);
7617       var $1606=(($1600+($1605<<2))|0);
7618       var $1607=$1606;
7619       var $1608=$1607;
7620       var $1609=HEAP32[(($1608)>>2)];
7621       var $1610=_prog_getedict($1597, $1609);
7622       $ed=$1610;
7623       var $1611=$ed;
7624       var $1612=$1611;
7625       var $1613=$2;
7626       var $1614=(($1613+64)|0);
7627       var $1615=HEAP32[(($1614)>>2)];
7628       var $1616=$st;
7629       var $1617=(($1616+4)|0);
7630       var $1618=$1617;
7631       var $1619=HEAP16[(($1618)>>1)];
7632       var $1620=(($1619)&65535);
7633       var $1621=(($1615+($1620<<2))|0);
7634       var $1622=$1621;
7635       var $1623=$1622;
7636       var $1624=HEAP32[(($1623)>>2)];
7637       var $1625=(($1612+($1624<<2))|0);
7638       var $1626=$1625;
7639       var $1627=$1626;
7640       var $1628=HEAP32[(($1627)>>2)];
7641       var $1629=$2;
7642       var $1630=(($1629+64)|0);
7643       var $1631=HEAP32[(($1630)>>2)];
7644       var $1632=$st;
7645       var $1633=(($1632+6)|0);
7646       var $1634=$1633;
7647       var $1635=HEAP16[(($1634)>>1)];
7648       var $1636=(($1635)&65535);
7649       var $1637=(($1631+($1636<<2))|0);
7650       var $1638=$1637;
7651       var $1639=$1638;
7652       HEAP32[(($1639)>>2)]=$1628;
7653       __label__ = 124; break;
7654     case 48:
7655       var $1641=$2;
7656       var $1642=(($1641+64)|0);
7657       var $1643=HEAP32[(($1642)>>2)];
7658       var $1644=$st;
7659       var $1645=(($1644+2)|0);
7660       var $1646=$1645;
7661       var $1647=HEAP16[(($1646)>>1)];
7662       var $1648=(($1647)&65535);
7663       var $1649=(($1643+($1648<<2))|0);
7664       var $1650=$1649;
7665       var $1651=$1650;
7666       var $1652=HEAP32[(($1651)>>2)];
7667       var $1653=(($1652)|0) < 0;
7668       if ($1653) { __label__ = 50; break; } else { __label__ = 49; break; }
7669     case 49:
7670       var $1655=$2;
7671       var $1656=(($1655+64)|0);
7672       var $1657=HEAP32[(($1656)>>2)];
7673       var $1658=$st;
7674       var $1659=(($1658+2)|0);
7675       var $1660=$1659;
7676       var $1661=HEAP16[(($1660)>>1)];
7677       var $1662=(($1661)&65535);
7678       var $1663=(($1657+($1662<<2))|0);
7679       var $1664=$1663;
7680       var $1665=$1664;
7681       var $1666=HEAP32[(($1665)>>2)];
7682       var $1667=$2;
7683       var $1668=(($1667+140)|0);
7684       var $1669=HEAP32[(($1668)>>2)];
7685       var $1670=(($1666)|0) >= (($1669)|0);
7686       if ($1670) { __label__ = 50; break; } else { __label__ = 51; break; }
7687     case 50:
7688       var $1672=$2;
7689       var $1673=$2;
7690       var $1674=(($1673)|0);
7691       var $1675=HEAP32[(($1674)>>2)];
7692       _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));
7693       __label__ = 488; break;
7694     case 51:
7695       var $1677=$2;
7696       var $1678=(($1677+64)|0);
7697       var $1679=HEAP32[(($1678)>>2)];
7698       var $1680=$st;
7699       var $1681=(($1680+4)|0);
7700       var $1682=$1681;
7701       var $1683=HEAP16[(($1682)>>1)];
7702       var $1684=(($1683)&65535);
7703       var $1685=(($1679+($1684<<2))|0);
7704       var $1686=$1685;
7705       var $1687=$1686;
7706       var $1688=HEAP32[(($1687)>>2)];
7707       var $1689=(($1688)|0) < 0;
7708       if ($1689) { __label__ = 53; break; } else { __label__ = 52; break; }
7709     case 52:
7710       var $1691=$2;
7711       var $1692=(($1691+64)|0);
7712       var $1693=HEAP32[(($1692)>>2)];
7713       var $1694=$st;
7714       var $1695=(($1694+4)|0);
7715       var $1696=$1695;
7716       var $1697=HEAP16[(($1696)>>1)];
7717       var $1698=(($1697)&65535);
7718       var $1699=(($1693+($1698<<2))|0);
7719       var $1700=$1699;
7720       var $1701=$1700;
7721       var $1702=HEAP32[(($1701)>>2)];
7722       var $1703=((($1702)+(3))|0);
7723       var $1704=$2;
7724       var $1705=(($1704+144)|0);
7725       var $1706=HEAP32[(($1705)>>2)];
7726       var $1707=(($1703)>>>0) > (($1706)>>>0);
7727       if ($1707) { __label__ = 53; break; } else { __label__ = 54; break; }
7728     case 53:
7729       var $1709=$2;
7730       var $1710=$2;
7731       var $1711=(($1710)|0);
7732       var $1712=HEAP32[(($1711)>>2)];
7733       var $1713=$2;
7734       var $1714=(($1713+64)|0);
7735       var $1715=HEAP32[(($1714)>>2)];
7736       var $1716=$st;
7737       var $1717=(($1716+4)|0);
7738       var $1718=$1717;
7739       var $1719=HEAP16[(($1718)>>1)];
7740       var $1720=(($1719)&65535);
7741       var $1721=(($1715+($1720<<2))|0);
7742       var $1722=$1721;
7743       var $1723=$1722;
7744       var $1724=HEAP32[(($1723)>>2)];
7745       var $1725=((($1724)+(2))|0);
7746       _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));
7747       __label__ = 488; break;
7748     case 54:
7749       var $1727=$2;
7750       var $1728=$2;
7751       var $1729=(($1728+64)|0);
7752       var $1730=HEAP32[(($1729)>>2)];
7753       var $1731=$st;
7754       var $1732=(($1731+2)|0);
7755       var $1733=$1732;
7756       var $1734=HEAP16[(($1733)>>1)];
7757       var $1735=(($1734)&65535);
7758       var $1736=(($1730+($1735<<2))|0);
7759       var $1737=$1736;
7760       var $1738=$1737;
7761       var $1739=HEAP32[(($1738)>>2)];
7762       var $1740=_prog_getedict($1727, $1739);
7763       $ed=$1740;
7764       var $1741=$ed;
7765       var $1742=$1741;
7766       var $1743=$2;
7767       var $1744=(($1743+64)|0);
7768       var $1745=HEAP32[(($1744)>>2)];
7769       var $1746=$st;
7770       var $1747=(($1746+4)|0);
7771       var $1748=$1747;
7772       var $1749=HEAP16[(($1748)>>1)];
7773       var $1750=(($1749)&65535);
7774       var $1751=(($1745+($1750<<2))|0);
7775       var $1752=$1751;
7776       var $1753=$1752;
7777       var $1754=HEAP32[(($1753)>>2)];
7778       var $1755=(($1742+($1754<<2))|0);
7779       var $1756=$1755;
7780       var $1757=$1756;
7781       var $1758=(($1757)|0);
7782       var $1759=HEAP32[(($1758)>>2)];
7783       var $1760=$2;
7784       var $1761=(($1760+64)|0);
7785       var $1762=HEAP32[(($1761)>>2)];
7786       var $1763=$st;
7787       var $1764=(($1763+6)|0);
7788       var $1765=$1764;
7789       var $1766=HEAP16[(($1765)>>1)];
7790       var $1767=(($1766)&65535);
7791       var $1768=(($1762+($1767<<2))|0);
7792       var $1769=$1768;
7793       var $1770=$1769;
7794       var $1771=(($1770)|0);
7795       HEAP32[(($1771)>>2)]=$1759;
7796       var $1772=$ed;
7797       var $1773=$1772;
7798       var $1774=$2;
7799       var $1775=(($1774+64)|0);
7800       var $1776=HEAP32[(($1775)>>2)];
7801       var $1777=$st;
7802       var $1778=(($1777+4)|0);
7803       var $1779=$1778;
7804       var $1780=HEAP16[(($1779)>>1)];
7805       var $1781=(($1780)&65535);
7806       var $1782=(($1776+($1781<<2))|0);
7807       var $1783=$1782;
7808       var $1784=$1783;
7809       var $1785=HEAP32[(($1784)>>2)];
7810       var $1786=(($1773+($1785<<2))|0);
7811       var $1787=$1786;
7812       var $1788=$1787;
7813       var $1789=(($1788+4)|0);
7814       var $1790=HEAP32[(($1789)>>2)];
7815       var $1791=$2;
7816       var $1792=(($1791+64)|0);
7817       var $1793=HEAP32[(($1792)>>2)];
7818       var $1794=$st;
7819       var $1795=(($1794+6)|0);
7820       var $1796=$1795;
7821       var $1797=HEAP16[(($1796)>>1)];
7822       var $1798=(($1797)&65535);
7823       var $1799=(($1793+($1798<<2))|0);
7824       var $1800=$1799;
7825       var $1801=$1800;
7826       var $1802=(($1801+4)|0);
7827       HEAP32[(($1802)>>2)]=$1790;
7828       var $1803=$ed;
7829       var $1804=$1803;
7830       var $1805=$2;
7831       var $1806=(($1805+64)|0);
7832       var $1807=HEAP32[(($1806)>>2)];
7833       var $1808=$st;
7834       var $1809=(($1808+4)|0);
7835       var $1810=$1809;
7836       var $1811=HEAP16[(($1810)>>1)];
7837       var $1812=(($1811)&65535);
7838       var $1813=(($1807+($1812<<2))|0);
7839       var $1814=$1813;
7840       var $1815=$1814;
7841       var $1816=HEAP32[(($1815)>>2)];
7842       var $1817=(($1804+($1816<<2))|0);
7843       var $1818=$1817;
7844       var $1819=$1818;
7845       var $1820=(($1819+8)|0);
7846       var $1821=HEAP32[(($1820)>>2)];
7847       var $1822=$2;
7848       var $1823=(($1822+64)|0);
7849       var $1824=HEAP32[(($1823)>>2)];
7850       var $1825=$st;
7851       var $1826=(($1825+6)|0);
7852       var $1827=$1826;
7853       var $1828=HEAP16[(($1827)>>1)];
7854       var $1829=(($1828)&65535);
7855       var $1830=(($1824+($1829<<2))|0);
7856       var $1831=$1830;
7857       var $1832=$1831;
7858       var $1833=(($1832+8)|0);
7859       HEAP32[(($1833)>>2)]=$1821;
7860       __label__ = 124; break;
7861     case 55:
7862       var $1835=$2;
7863       var $1836=(($1835+64)|0);
7864       var $1837=HEAP32[(($1836)>>2)];
7865       var $1838=$st;
7866       var $1839=(($1838+2)|0);
7867       var $1840=$1839;
7868       var $1841=HEAP16[(($1840)>>1)];
7869       var $1842=(($1841)&65535);
7870       var $1843=(($1837+($1842<<2))|0);
7871       var $1844=$1843;
7872       var $1845=$1844;
7873       var $1846=HEAP32[(($1845)>>2)];
7874       var $1847=(($1846)|0) < 0;
7875       if ($1847) { __label__ = 57; break; } else { __label__ = 56; break; }
7876     case 56:
7877       var $1849=$2;
7878       var $1850=(($1849+64)|0);
7879       var $1851=HEAP32[(($1850)>>2)];
7880       var $1852=$st;
7881       var $1853=(($1852+2)|0);
7882       var $1854=$1853;
7883       var $1855=HEAP16[(($1854)>>1)];
7884       var $1856=(($1855)&65535);
7885       var $1857=(($1851+($1856<<2))|0);
7886       var $1858=$1857;
7887       var $1859=$1858;
7888       var $1860=HEAP32[(($1859)>>2)];
7889       var $1861=$2;
7890       var $1862=(($1861+140)|0);
7891       var $1863=HEAP32[(($1862)>>2)];
7892       var $1864=(($1860)|0) >= (($1863)|0);
7893       if ($1864) { __label__ = 57; break; } else { __label__ = 58; break; }
7894     case 57:
7895       var $1866=$2;
7896       var $1867=$2;
7897       var $1868=(($1867)|0);
7898       var $1869=HEAP32[(($1868)>>2)];
7899       var $1870=$2;
7900       var $1871=(($1870+64)|0);
7901       var $1872=HEAP32[(($1871)>>2)];
7902       var $1873=$st;
7903       var $1874=(($1873+2)|0);
7904       var $1875=$1874;
7905       var $1876=HEAP16[(($1875)>>1)];
7906       var $1877=(($1876)&65535);
7907       var $1878=(($1872+($1877<<2))|0);
7908       var $1879=$1878;
7909       var $1880=$1879;
7910       var $1881=HEAP32[(($1880)>>2)];
7911       _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));
7912       __label__ = 488; break;
7913     case 58:
7914       var $1883=$2;
7915       var $1884=(($1883+64)|0);
7916       var $1885=HEAP32[(($1884)>>2)];
7917       var $1886=$st;
7918       var $1887=(($1886+4)|0);
7919       var $1888=$1887;
7920       var $1889=HEAP16[(($1888)>>1)];
7921       var $1890=(($1889)&65535);
7922       var $1891=(($1885+($1890<<2))|0);
7923       var $1892=$1891;
7924       var $1893=$1892;
7925       var $1894=HEAP32[(($1893)>>2)];
7926       var $1895=$2;
7927       var $1896=(($1895+144)|0);
7928       var $1897=HEAP32[(($1896)>>2)];
7929       var $1898=(($1894)>>>0) >= (($1897)>>>0);
7930       if ($1898) { __label__ = 59; break; } else { __label__ = 60; break; }
7931     case 59:
7932       var $1900=$2;
7933       var $1901=$2;
7934       var $1902=(($1901)|0);
7935       var $1903=HEAP32[(($1902)>>2)];
7936       var $1904=$2;
7937       var $1905=(($1904+64)|0);
7938       var $1906=HEAP32[(($1905)>>2)];
7939       var $1907=$st;
7940       var $1908=(($1907+4)|0);
7941       var $1909=$1908;
7942       var $1910=HEAP16[(($1909)>>1)];
7943       var $1911=(($1910)&65535);
7944       var $1912=(($1906+($1911<<2))|0);
7945       var $1913=$1912;
7946       var $1914=$1913;
7947       var $1915=HEAP32[(($1914)>>2)];
7948       _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));
7949       __label__ = 488; break;
7950     case 60:
7951       var $1917=$2;
7952       var $1918=$2;
7953       var $1919=(($1918+64)|0);
7954       var $1920=HEAP32[(($1919)>>2)];
7955       var $1921=$st;
7956       var $1922=(($1921+2)|0);
7957       var $1923=$1922;
7958       var $1924=HEAP16[(($1923)>>1)];
7959       var $1925=(($1924)&65535);
7960       var $1926=(($1920+($1925<<2))|0);
7961       var $1927=$1926;
7962       var $1928=$1927;
7963       var $1929=HEAP32[(($1928)>>2)];
7964       var $1930=_prog_getedict($1917, $1929);
7965       $ed=$1930;
7966       var $1931=$ed;
7967       var $1932=$1931;
7968       var $1933=$2;
7969       var $1934=(($1933+76)|0);
7970       var $1935=HEAP32[(($1934)>>2)];
7971       var $1936=$1932;
7972       var $1937=$1935;
7973       var $1938=((($1936)-($1937))|0);
7974       var $1939=((((($1938)|0))/(4))&-1);
7975       var $1940=$2;
7976       var $1941=(($1940+64)|0);
7977       var $1942=HEAP32[(($1941)>>2)];
7978       var $1943=$st;
7979       var $1944=(($1943+6)|0);
7980       var $1945=$1944;
7981       var $1946=HEAP16[(($1945)>>1)];
7982       var $1947=(($1946)&65535);
7983       var $1948=(($1942+($1947<<2))|0);
7984       var $1949=$1948;
7985       var $1950=$1949;
7986       HEAP32[(($1950)>>2)]=$1939;
7987       var $1951=$2;
7988       var $1952=(($1951+64)|0);
7989       var $1953=HEAP32[(($1952)>>2)];
7990       var $1954=$st;
7991       var $1955=(($1954+4)|0);
7992       var $1956=$1955;
7993       var $1957=HEAP16[(($1956)>>1)];
7994       var $1958=(($1957)&65535);
7995       var $1959=(($1953+($1958<<2))|0);
7996       var $1960=$1959;
7997       var $1961=$1960;
7998       var $1962=HEAP32[(($1961)>>2)];
7999       var $1963=$2;
8000       var $1964=(($1963+64)|0);
8001       var $1965=HEAP32[(($1964)>>2)];
8002       var $1966=$st;
8003       var $1967=(($1966+6)|0);
8004       var $1968=$1967;
8005       var $1969=HEAP16[(($1968)>>1)];
8006       var $1970=(($1969)&65535);
8007       var $1971=(($1965+($1970<<2))|0);
8008       var $1972=$1971;
8009       var $1973=$1972;
8010       var $1974=HEAP32[(($1973)>>2)];
8011       var $1975=((($1974)+($1962))|0);
8012       HEAP32[(($1973)>>2)]=$1975;
8013       __label__ = 124; break;
8014     case 61:
8015       var $1977=$2;
8016       var $1978=(($1977+64)|0);
8017       var $1979=HEAP32[(($1978)>>2)];
8018       var $1980=$st;
8019       var $1981=(($1980+2)|0);
8020       var $1982=$1981;
8021       var $1983=HEAP16[(($1982)>>1)];
8022       var $1984=(($1983)&65535);
8023       var $1985=(($1979+($1984<<2))|0);
8024       var $1986=$1985;
8025       var $1987=$1986;
8026       var $1988=HEAP32[(($1987)>>2)];
8027       var $1989=$2;
8028       var $1990=(($1989+64)|0);
8029       var $1991=HEAP32[(($1990)>>2)];
8030       var $1992=$st;
8031       var $1993=(($1992+4)|0);
8032       var $1994=$1993;
8033       var $1995=HEAP16[(($1994)>>1)];
8034       var $1996=(($1995)&65535);
8035       var $1997=(($1991+($1996<<2))|0);
8036       var $1998=$1997;
8037       var $1999=$1998;
8038       HEAP32[(($1999)>>2)]=$1988;
8039       __label__ = 124; break;
8040     case 62:
8041       var $2001=$2;
8042       var $2002=(($2001+64)|0);
8043       var $2003=HEAP32[(($2002)>>2)];
8044       var $2004=$st;
8045       var $2005=(($2004+2)|0);
8046       var $2006=$2005;
8047       var $2007=HEAP16[(($2006)>>1)];
8048       var $2008=(($2007)&65535);
8049       var $2009=(($2003+($2008<<2))|0);
8050       var $2010=$2009;
8051       var $2011=$2010;
8052       var $2012=(($2011)|0);
8053       var $2013=HEAP32[(($2012)>>2)];
8054       var $2014=$2;
8055       var $2015=(($2014+64)|0);
8056       var $2016=HEAP32[(($2015)>>2)];
8057       var $2017=$st;
8058       var $2018=(($2017+4)|0);
8059       var $2019=$2018;
8060       var $2020=HEAP16[(($2019)>>1)];
8061       var $2021=(($2020)&65535);
8062       var $2022=(($2016+($2021<<2))|0);
8063       var $2023=$2022;
8064       var $2024=$2023;
8065       var $2025=(($2024)|0);
8066       HEAP32[(($2025)>>2)]=$2013;
8067       var $2026=$2;
8068       var $2027=(($2026+64)|0);
8069       var $2028=HEAP32[(($2027)>>2)];
8070       var $2029=$st;
8071       var $2030=(($2029+2)|0);
8072       var $2031=$2030;
8073       var $2032=HEAP16[(($2031)>>1)];
8074       var $2033=(($2032)&65535);
8075       var $2034=(($2028+($2033<<2))|0);
8076       var $2035=$2034;
8077       var $2036=$2035;
8078       var $2037=(($2036+4)|0);
8079       var $2038=HEAP32[(($2037)>>2)];
8080       var $2039=$2;
8081       var $2040=(($2039+64)|0);
8082       var $2041=HEAP32[(($2040)>>2)];
8083       var $2042=$st;
8084       var $2043=(($2042+4)|0);
8085       var $2044=$2043;
8086       var $2045=HEAP16[(($2044)>>1)];
8087       var $2046=(($2045)&65535);
8088       var $2047=(($2041+($2046<<2))|0);
8089       var $2048=$2047;
8090       var $2049=$2048;
8091       var $2050=(($2049+4)|0);
8092       HEAP32[(($2050)>>2)]=$2038;
8093       var $2051=$2;
8094       var $2052=(($2051+64)|0);
8095       var $2053=HEAP32[(($2052)>>2)];
8096       var $2054=$st;
8097       var $2055=(($2054+2)|0);
8098       var $2056=$2055;
8099       var $2057=HEAP16[(($2056)>>1)];
8100       var $2058=(($2057)&65535);
8101       var $2059=(($2053+($2058<<2))|0);
8102       var $2060=$2059;
8103       var $2061=$2060;
8104       var $2062=(($2061+8)|0);
8105       var $2063=HEAP32[(($2062)>>2)];
8106       var $2064=$2;
8107       var $2065=(($2064+64)|0);
8108       var $2066=HEAP32[(($2065)>>2)];
8109       var $2067=$st;
8110       var $2068=(($2067+4)|0);
8111       var $2069=$2068;
8112       var $2070=HEAP16[(($2069)>>1)];
8113       var $2071=(($2070)&65535);
8114       var $2072=(($2066+($2071<<2))|0);
8115       var $2073=$2072;
8116       var $2074=$2073;
8117       var $2075=(($2074+8)|0);
8118       HEAP32[(($2075)>>2)]=$2063;
8119       __label__ = 124; break;
8120     case 63:
8121       var $2077=$2;
8122       var $2078=(($2077+64)|0);
8123       var $2079=HEAP32[(($2078)>>2)];
8124       var $2080=$st;
8125       var $2081=(($2080+4)|0);
8126       var $2082=$2081;
8127       var $2083=HEAP16[(($2082)>>1)];
8128       var $2084=(($2083)&65535);
8129       var $2085=(($2079+($2084<<2))|0);
8130       var $2086=$2085;
8131       var $2087=$2086;
8132       var $2088=HEAP32[(($2087)>>2)];
8133       var $2089=(($2088)|0) < 0;
8134       if ($2089) { __label__ = 65; break; } else { __label__ = 64; break; }
8135     case 64:
8136       var $2091=$2;
8137       var $2092=(($2091+64)|0);
8138       var $2093=HEAP32[(($2092)>>2)];
8139       var $2094=$st;
8140       var $2095=(($2094+4)|0);
8141       var $2096=$2095;
8142       var $2097=HEAP16[(($2096)>>1)];
8143       var $2098=(($2097)&65535);
8144       var $2099=(($2093+($2098<<2))|0);
8145       var $2100=$2099;
8146       var $2101=$2100;
8147       var $2102=HEAP32[(($2101)>>2)];
8148       var $2103=$2;
8149       var $2104=(($2103+80)|0);
8150       var $2105=HEAP32[(($2104)>>2)];
8151       var $2106=(($2102)>>>0) >= (($2105)>>>0);
8152       if ($2106) { __label__ = 65; break; } else { __label__ = 66; break; }
8153     case 65:
8154       var $2108=$2;
8155       var $2109=$2;
8156       var $2110=(($2109)|0);
8157       var $2111=HEAP32[(($2110)>>2)];
8158       var $2112=$2;
8159       var $2113=(($2112+64)|0);
8160       var $2114=HEAP32[(($2113)>>2)];
8161       var $2115=$st;
8162       var $2116=(($2115+4)|0);
8163       var $2117=$2116;
8164       var $2118=HEAP16[(($2117)>>1)];
8165       var $2119=(($2118)&65535);
8166       var $2120=(($2114+($2119<<2))|0);
8167       var $2121=$2120;
8168       var $2122=$2121;
8169       var $2123=HEAP32[(($2122)>>2)];
8170       _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));
8171       __label__ = 488; break;
8172     case 66:
8173       var $2125=$2;
8174       var $2126=(($2125+64)|0);
8175       var $2127=HEAP32[(($2126)>>2)];
8176       var $2128=$st;
8177       var $2129=(($2128+4)|0);
8178       var $2130=$2129;
8179       var $2131=HEAP16[(($2130)>>1)];
8180       var $2132=(($2131)&65535);
8181       var $2133=(($2127+($2132<<2))|0);
8182       var $2134=$2133;
8183       var $2135=$2134;
8184       var $2136=HEAP32[(($2135)>>2)];
8185       var $2137=$2;
8186       var $2138=(($2137+144)|0);
8187       var $2139=HEAP32[(($2138)>>2)];
8188       var $2140=(($2136)>>>0) < (($2139)>>>0);
8189       if ($2140) { __label__ = 67; break; } else { __label__ = 69; break; }
8190     case 67:
8191       var $2142=$2;
8192       var $2143=(($2142+148)|0);
8193       var $2144=HEAP8[($2143)];
8194       var $2145=(($2144) & 1);
8195       if ($2145) { __label__ = 69; break; } else { __label__ = 68; break; }
8196     case 68:
8197       var $2147=$2;
8198       var $2148=$2;
8199       var $2149=(($2148)|0);
8200       var $2150=HEAP32[(($2149)>>2)];
8201       var $2151=$2;
8202       var $2152=$2;
8203       var $2153=$2;
8204       var $2154=(($2153+64)|0);
8205       var $2155=HEAP32[(($2154)>>2)];
8206       var $2156=$st;
8207       var $2157=(($2156+4)|0);
8208       var $2158=$2157;
8209       var $2159=HEAP16[(($2158)>>1)];
8210       var $2160=(($2159)&65535);
8211       var $2161=(($2155+($2160<<2))|0);
8212       var $2162=$2161;
8213       var $2163=$2162;
8214       var $2164=HEAP32[(($2163)>>2)];
8215       var $2165=_prog_entfield($2152, $2164);
8216       var $2166=(($2165+4)|0);
8217       var $2167=HEAP32[(($2166)>>2)];
8218       var $2168=_prog_getstring($2151, $2167);
8219       var $2169=$2;
8220       var $2170=(($2169+64)|0);
8221       var $2171=HEAP32[(($2170)>>2)];
8222       var $2172=$st;
8223       var $2173=(($2172+4)|0);
8224       var $2174=$2173;
8225       var $2175=HEAP16[(($2174)>>1)];
8226       var $2176=(($2175)&65535);
8227       var $2177=(($2171+($2176<<2))|0);
8228       var $2178=$2177;
8229       var $2179=$2178;
8230       var $2180=HEAP32[(($2179)>>2)];
8231       _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));
8232       __label__ = 69; break;
8233     case 69:
8234       var $2182=$2;
8235       var $2183=(($2182+76)|0);
8236       var $2184=HEAP32[(($2183)>>2)];
8237       var $2185=$2;
8238       var $2186=(($2185+64)|0);
8239       var $2187=HEAP32[(($2186)>>2)];
8240       var $2188=$st;
8241       var $2189=(($2188+4)|0);
8242       var $2190=$2189;
8243       var $2191=HEAP16[(($2190)>>1)];
8244       var $2192=(($2191)&65535);
8245       var $2193=(($2187+($2192<<2))|0);
8246       var $2194=$2193;
8247       var $2195=$2194;
8248       var $2196=HEAP32[(($2195)>>2)];
8249       var $2197=(($2184+($2196<<2))|0);
8250       var $2198=$2197;
8251       $ptr=$2198;
8252       var $2199=$2;
8253       var $2200=(($2199+64)|0);
8254       var $2201=HEAP32[(($2200)>>2)];
8255       var $2202=$st;
8256       var $2203=(($2202+2)|0);
8257       var $2204=$2203;
8258       var $2205=HEAP16[(($2204)>>1)];
8259       var $2206=(($2205)&65535);
8260       var $2207=(($2201+($2206<<2))|0);
8261       var $2208=$2207;
8262       var $2209=$2208;
8263       var $2210=HEAP32[(($2209)>>2)];
8264       var $2211=$ptr;
8265       var $2212=$2211;
8266       HEAP32[(($2212)>>2)]=$2210;
8267       __label__ = 124; break;
8268     case 70:
8269       var $2214=$2;
8270       var $2215=(($2214+64)|0);
8271       var $2216=HEAP32[(($2215)>>2)];
8272       var $2217=$st;
8273       var $2218=(($2217+4)|0);
8274       var $2219=$2218;
8275       var $2220=HEAP16[(($2219)>>1)];
8276       var $2221=(($2220)&65535);
8277       var $2222=(($2216+($2221<<2))|0);
8278       var $2223=$2222;
8279       var $2224=$2223;
8280       var $2225=HEAP32[(($2224)>>2)];
8281       var $2226=(($2225)|0) < 0;
8282       if ($2226) { __label__ = 72; break; } else { __label__ = 71; break; }
8283     case 71:
8284       var $2228=$2;
8285       var $2229=(($2228+64)|0);
8286       var $2230=HEAP32[(($2229)>>2)];
8287       var $2231=$st;
8288       var $2232=(($2231+4)|0);
8289       var $2233=$2232;
8290       var $2234=HEAP16[(($2233)>>1)];
8291       var $2235=(($2234)&65535);
8292       var $2236=(($2230+($2235<<2))|0);
8293       var $2237=$2236;
8294       var $2238=$2237;
8295       var $2239=HEAP32[(($2238)>>2)];
8296       var $2240=((($2239)+(2))|0);
8297       var $2241=$2;
8298       var $2242=(($2241+80)|0);
8299       var $2243=HEAP32[(($2242)>>2)];
8300       var $2244=(($2240)>>>0) >= (($2243)>>>0);
8301       if ($2244) { __label__ = 72; break; } else { __label__ = 73; break; }
8302     case 72:
8303       var $2246=$2;
8304       var $2247=$2;
8305       var $2248=(($2247)|0);
8306       var $2249=HEAP32[(($2248)>>2)];
8307       var $2250=$2;
8308       var $2251=(($2250+64)|0);
8309       var $2252=HEAP32[(($2251)>>2)];
8310       var $2253=$st;
8311       var $2254=(($2253+4)|0);
8312       var $2255=$2254;
8313       var $2256=HEAP16[(($2255)>>1)];
8314       var $2257=(($2256)&65535);
8315       var $2258=(($2252+($2257<<2))|0);
8316       var $2259=$2258;
8317       var $2260=$2259;
8318       var $2261=HEAP32[(($2260)>>2)];
8319       _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));
8320       __label__ = 488; break;
8321     case 73:
8322       var $2263=$2;
8323       var $2264=(($2263+64)|0);
8324       var $2265=HEAP32[(($2264)>>2)];
8325       var $2266=$st;
8326       var $2267=(($2266+4)|0);
8327       var $2268=$2267;
8328       var $2269=HEAP16[(($2268)>>1)];
8329       var $2270=(($2269)&65535);
8330       var $2271=(($2265+($2270<<2))|0);
8331       var $2272=$2271;
8332       var $2273=$2272;
8333       var $2274=HEAP32[(($2273)>>2)];
8334       var $2275=$2;
8335       var $2276=(($2275+144)|0);
8336       var $2277=HEAP32[(($2276)>>2)];
8337       var $2278=(($2274)>>>0) < (($2277)>>>0);
8338       if ($2278) { __label__ = 74; break; } else { __label__ = 76; break; }
8339     case 74:
8340       var $2280=$2;
8341       var $2281=(($2280+148)|0);
8342       var $2282=HEAP8[($2281)];
8343       var $2283=(($2282) & 1);
8344       if ($2283) { __label__ = 76; break; } else { __label__ = 75; break; }
8345     case 75:
8346       var $2285=$2;
8347       var $2286=$2;
8348       var $2287=(($2286)|0);
8349       var $2288=HEAP32[(($2287)>>2)];
8350       var $2289=$2;
8351       var $2290=$2;
8352       var $2291=$2;
8353       var $2292=(($2291+64)|0);
8354       var $2293=HEAP32[(($2292)>>2)];
8355       var $2294=$st;
8356       var $2295=(($2294+4)|0);
8357       var $2296=$2295;
8358       var $2297=HEAP16[(($2296)>>1)];
8359       var $2298=(($2297)&65535);
8360       var $2299=(($2293+($2298<<2))|0);
8361       var $2300=$2299;
8362       var $2301=$2300;
8363       var $2302=HEAP32[(($2301)>>2)];
8364       var $2303=_prog_entfield($2290, $2302);
8365       var $2304=(($2303+4)|0);
8366       var $2305=HEAP32[(($2304)>>2)];
8367       var $2306=_prog_getstring($2289, $2305);
8368       var $2307=$2;
8369       var $2308=(($2307+64)|0);
8370       var $2309=HEAP32[(($2308)>>2)];
8371       var $2310=$st;
8372       var $2311=(($2310+4)|0);
8373       var $2312=$2311;
8374       var $2313=HEAP16[(($2312)>>1)];
8375       var $2314=(($2313)&65535);
8376       var $2315=(($2309+($2314<<2))|0);
8377       var $2316=$2315;
8378       var $2317=$2316;
8379       var $2318=HEAP32[(($2317)>>2)];
8380       _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));
8381       __label__ = 76; break;
8382     case 76:
8383       var $2320=$2;
8384       var $2321=(($2320+76)|0);
8385       var $2322=HEAP32[(($2321)>>2)];
8386       var $2323=$2;
8387       var $2324=(($2323+64)|0);
8388       var $2325=HEAP32[(($2324)>>2)];
8389       var $2326=$st;
8390       var $2327=(($2326+4)|0);
8391       var $2328=$2327;
8392       var $2329=HEAP16[(($2328)>>1)];
8393       var $2330=(($2329)&65535);
8394       var $2331=(($2325+($2330<<2))|0);
8395       var $2332=$2331;
8396       var $2333=$2332;
8397       var $2334=HEAP32[(($2333)>>2)];
8398       var $2335=(($2322+($2334<<2))|0);
8399       var $2336=$2335;
8400       $ptr=$2336;
8401       var $2337=$2;
8402       var $2338=(($2337+64)|0);
8403       var $2339=HEAP32[(($2338)>>2)];
8404       var $2340=$st;
8405       var $2341=(($2340+2)|0);
8406       var $2342=$2341;
8407       var $2343=HEAP16[(($2342)>>1)];
8408       var $2344=(($2343)&65535);
8409       var $2345=(($2339+($2344<<2))|0);
8410       var $2346=$2345;
8411       var $2347=$2346;
8412       var $2348=(($2347)|0);
8413       var $2349=HEAP32[(($2348)>>2)];
8414       var $2350=$ptr;
8415       var $2351=$2350;
8416       var $2352=(($2351)|0);
8417       HEAP32[(($2352)>>2)]=$2349;
8418       var $2353=$2;
8419       var $2354=(($2353+64)|0);
8420       var $2355=HEAP32[(($2354)>>2)];
8421       var $2356=$st;
8422       var $2357=(($2356+2)|0);
8423       var $2358=$2357;
8424       var $2359=HEAP16[(($2358)>>1)];
8425       var $2360=(($2359)&65535);
8426       var $2361=(($2355+($2360<<2))|0);
8427       var $2362=$2361;
8428       var $2363=$2362;
8429       var $2364=(($2363+4)|0);
8430       var $2365=HEAP32[(($2364)>>2)];
8431       var $2366=$ptr;
8432       var $2367=$2366;
8433       var $2368=(($2367+4)|0);
8434       HEAP32[(($2368)>>2)]=$2365;
8435       var $2369=$2;
8436       var $2370=(($2369+64)|0);
8437       var $2371=HEAP32[(($2370)>>2)];
8438       var $2372=$st;
8439       var $2373=(($2372+2)|0);
8440       var $2374=$2373;
8441       var $2375=HEAP16[(($2374)>>1)];
8442       var $2376=(($2375)&65535);
8443       var $2377=(($2371+($2376<<2))|0);
8444       var $2378=$2377;
8445       var $2379=$2378;
8446       var $2380=(($2379+8)|0);
8447       var $2381=HEAP32[(($2380)>>2)];
8448       var $2382=$ptr;
8449       var $2383=$2382;
8450       var $2384=(($2383+8)|0);
8451       HEAP32[(($2384)>>2)]=$2381;
8452       __label__ = 124; break;
8453     case 77:
8454       var $2386=$2;
8455       var $2387=(($2386+64)|0);
8456       var $2388=HEAP32[(($2387)>>2)];
8457       var $2389=$st;
8458       var $2390=(($2389+2)|0);
8459       var $2391=$2390;
8460       var $2392=HEAP16[(($2391)>>1)];
8461       var $2393=(($2392)&65535);
8462       var $2394=(($2388+($2393<<2))|0);
8463       var $2395=$2394;
8464       var $2396=$2395;
8465       var $2397=HEAP32[(($2396)>>2)];
8466       var $2398=$2397 & 2147483647;
8467       var $2399=(($2398)|0)!=0;
8468       var $2400=$2399 ^ 1;
8469       var $2401=(($2400)&1);
8470       var $2402=(($2401)|0);
8471       var $2403=$2;
8472       var $2404=(($2403+64)|0);
8473       var $2405=HEAP32[(($2404)>>2)];
8474       var $2406=$st;
8475       var $2407=(($2406+6)|0);
8476       var $2408=$2407;
8477       var $2409=HEAP16[(($2408)>>1)];
8478       var $2410=(($2409)&65535);
8479       var $2411=(($2405+($2410<<2))|0);
8480       var $2412=$2411;
8481       var $2413=$2412;
8482       HEAPF32[(($2413)>>2)]=$2402;
8483       __label__ = 124; break;
8484     case 78:
8485       var $2415=$2;
8486       var $2416=(($2415+64)|0);
8487       var $2417=HEAP32[(($2416)>>2)];
8488       var $2418=$st;
8489       var $2419=(($2418+2)|0);
8490       var $2420=$2419;
8491       var $2421=HEAP16[(($2420)>>1)];
8492       var $2422=(($2421)&65535);
8493       var $2423=(($2417+($2422<<2))|0);
8494       var $2424=$2423;
8495       var $2425=$2424;
8496       var $2426=(($2425)|0);
8497       var $2427=HEAPF32[(($2426)>>2)];
8498       var $2428=$2427 != 0;
8499       if ($2428) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 79; break; }
8500     case 79:
8501       var $2430=$2;
8502       var $2431=(($2430+64)|0);
8503       var $2432=HEAP32[(($2431)>>2)];
8504       var $2433=$st;
8505       var $2434=(($2433+2)|0);
8506       var $2435=$2434;
8507       var $2436=HEAP16[(($2435)>>1)];
8508       var $2437=(($2436)&65535);
8509       var $2438=(($2432+($2437<<2))|0);
8510       var $2439=$2438;
8511       var $2440=$2439;
8512       var $2441=(($2440+4)|0);
8513       var $2442=HEAPF32[(($2441)>>2)];
8514       var $2443=$2442 != 0;
8515       if ($2443) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 80; break; }
8516     case 80:
8517       var $2445=$2;
8518       var $2446=(($2445+64)|0);
8519       var $2447=HEAP32[(($2446)>>2)];
8520       var $2448=$st;
8521       var $2449=(($2448+2)|0);
8522       var $2450=$2449;
8523       var $2451=HEAP16[(($2450)>>1)];
8524       var $2452=(($2451)&65535);
8525       var $2453=(($2447+($2452<<2))|0);
8526       var $2454=$2453;
8527       var $2455=$2454;
8528       var $2456=(($2455+8)|0);
8529       var $2457=HEAPF32[(($2456)>>2)];
8530       var $2458=$2457 != 0;
8531       var $2459=$2458 ^ 1;
8532       var $2461 = $2459;__label__ = 81; break;
8533     case 81:
8534       var $2461;
8535       var $2462=(($2461)&1);
8536       var $2463=(($2462)|0);
8537       var $2464=$2;
8538       var $2465=(($2464+64)|0);
8539       var $2466=HEAP32[(($2465)>>2)];
8540       var $2467=$st;
8541       var $2468=(($2467+6)|0);
8542       var $2469=$2468;
8543       var $2470=HEAP16[(($2469)>>1)];
8544       var $2471=(($2470)&65535);
8545       var $2472=(($2466+($2471<<2))|0);
8546       var $2473=$2472;
8547       var $2474=$2473;
8548       HEAPF32[(($2474)>>2)]=$2463;
8549       __label__ = 124; break;
8550     case 82:
8551       var $2476=$2;
8552       var $2477=(($2476+64)|0);
8553       var $2478=HEAP32[(($2477)>>2)];
8554       var $2479=$st;
8555       var $2480=(($2479+2)|0);
8556       var $2481=$2480;
8557       var $2482=HEAP16[(($2481)>>1)];
8558       var $2483=(($2482)&65535);
8559       var $2484=(($2478+($2483<<2))|0);
8560       var $2485=$2484;
8561       var $2486=$2485;
8562       var $2487=HEAP32[(($2486)>>2)];
8563       var $2488=(($2487)|0)!=0;
8564       if ($2488) { __label__ = 83; break; } else { var $2508 = 1;__label__ = 84; break; }
8565     case 83:
8566       var $2490=$2;
8567       var $2491=$2;
8568       var $2492=(($2491+64)|0);
8569       var $2493=HEAP32[(($2492)>>2)];
8570       var $2494=$st;
8571       var $2495=(($2494+2)|0);
8572       var $2496=$2495;
8573       var $2497=HEAP16[(($2496)>>1)];
8574       var $2498=(($2497)&65535);
8575       var $2499=(($2493+($2498<<2))|0);
8576       var $2500=$2499;
8577       var $2501=$2500;
8578       var $2502=HEAP32[(($2501)>>2)];
8579       var $2503=_prog_getstring($2490, $2502);
8580       var $2504=HEAP8[($2503)];
8581       var $2505=(($2504 << 24) >> 24)!=0;
8582       var $2506=$2505 ^ 1;
8583       var $2508 = $2506;__label__ = 84; break;
8584     case 84:
8585       var $2508;
8586       var $2509=(($2508)&1);
8587       var $2510=(($2509)|0);
8588       var $2511=$2;
8589       var $2512=(($2511+64)|0);
8590       var $2513=HEAP32[(($2512)>>2)];
8591       var $2514=$st;
8592       var $2515=(($2514+6)|0);
8593       var $2516=$2515;
8594       var $2517=HEAP16[(($2516)>>1)];
8595       var $2518=(($2517)&65535);
8596       var $2519=(($2513+($2518<<2))|0);
8597       var $2520=$2519;
8598       var $2521=$2520;
8599       HEAPF32[(($2521)>>2)]=$2510;
8600       __label__ = 124; break;
8601     case 85:
8602       var $2523=$2;
8603       var $2524=(($2523+64)|0);
8604       var $2525=HEAP32[(($2524)>>2)];
8605       var $2526=$st;
8606       var $2527=(($2526+2)|0);
8607       var $2528=$2527;
8608       var $2529=HEAP16[(($2528)>>1)];
8609       var $2530=(($2529)&65535);
8610       var $2531=(($2525+($2530<<2))|0);
8611       var $2532=$2531;
8612       var $2533=$2532;
8613       var $2534=HEAP32[(($2533)>>2)];
8614       var $2535=(($2534)|0)==0;
8615       var $2536=(($2535)&1);
8616       var $2537=(($2536)|0);
8617       var $2538=$2;
8618       var $2539=(($2538+64)|0);
8619       var $2540=HEAP32[(($2539)>>2)];
8620       var $2541=$st;
8621       var $2542=(($2541+6)|0);
8622       var $2543=$2542;
8623       var $2544=HEAP16[(($2543)>>1)];
8624       var $2545=(($2544)&65535);
8625       var $2546=(($2540+($2545<<2))|0);
8626       var $2547=$2546;
8627       var $2548=$2547;
8628       HEAPF32[(($2548)>>2)]=$2537;
8629       __label__ = 124; break;
8630     case 86:
8631       var $2550=$2;
8632       var $2551=(($2550+64)|0);
8633       var $2552=HEAP32[(($2551)>>2)];
8634       var $2553=$st;
8635       var $2554=(($2553+2)|0);
8636       var $2555=$2554;
8637       var $2556=HEAP16[(($2555)>>1)];
8638       var $2557=(($2556)&65535);
8639       var $2558=(($2552+($2557<<2))|0);
8640       var $2559=$2558;
8641       var $2560=$2559;
8642       var $2561=HEAP32[(($2560)>>2)];
8643       var $2562=(($2561)|0)!=0;
8644       var $2563=$2562 ^ 1;
8645       var $2564=(($2563)&1);
8646       var $2565=(($2564)|0);
8647       var $2566=$2;
8648       var $2567=(($2566+64)|0);
8649       var $2568=HEAP32[(($2567)>>2)];
8650       var $2569=$st;
8651       var $2570=(($2569+6)|0);
8652       var $2571=$2570;
8653       var $2572=HEAP16[(($2571)>>1)];
8654       var $2573=(($2572)&65535);
8655       var $2574=(($2568+($2573<<2))|0);
8656       var $2575=$2574;
8657       var $2576=$2575;
8658       HEAPF32[(($2576)>>2)]=$2565;
8659       __label__ = 124; break;
8660     case 87:
8661       var $2578=$2;
8662       var $2579=(($2578+64)|0);
8663       var $2580=HEAP32[(($2579)>>2)];
8664       var $2581=$st;
8665       var $2582=(($2581+2)|0);
8666       var $2583=$2582;
8667       var $2584=HEAP16[(($2583)>>1)];
8668       var $2585=(($2584)&65535);
8669       var $2586=(($2580+($2585<<2))|0);
8670       var $2587=$2586;
8671       var $2588=$2587;
8672       var $2589=HEAP32[(($2588)>>2)];
8673       var $2590=$2589 & 2147483647;
8674       var $2591=(($2590)|0)!=0;
8675       if ($2591) { __label__ = 88; break; } else { __label__ = 91; break; }
8676     case 88:
8677       var $2593=$st;
8678       var $2594=(($2593+4)|0);
8679       var $2595=$2594;
8680       var $2596=HEAP16[(($2595)>>1)];
8681       var $2597=(($2596 << 16) >> 16);
8682       var $2598=((($2597)-(1))|0);
8683       var $2599=$st;
8684       var $2600=(($2599+($2598<<3))|0);
8685       $st=$2600;
8686       var $2601=$jumpcount;
8687       var $2602=((($2601)+(1))|0);
8688       $jumpcount=$2602;
8689       var $2603=$5;
8690       var $2604=(($2602)|0) >= (($2603)|0);
8691       if ($2604) { __label__ = 89; break; } else { __label__ = 90; break; }
8692     case 89:
8693       var $2606=$2;
8694       var $2607=$2;
8695       var $2608=(($2607)|0);
8696       var $2609=HEAP32[(($2608)>>2)];
8697       var $2610=$jumpcount;
8698       _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));
8699       __label__ = 90; break;
8700     case 90:
8701       __label__ = 91; break;
8702     case 91:
8703       __label__ = 124; break;
8704     case 92:
8705       var $2614=$2;
8706       var $2615=(($2614+64)|0);
8707       var $2616=HEAP32[(($2615)>>2)];
8708       var $2617=$st;
8709       var $2618=(($2617+2)|0);
8710       var $2619=$2618;
8711       var $2620=HEAP16[(($2619)>>1)];
8712       var $2621=(($2620)&65535);
8713       var $2622=(($2616+($2621<<2))|0);
8714       var $2623=$2622;
8715       var $2624=$2623;
8716       var $2625=HEAP32[(($2624)>>2)];
8717       var $2626=$2625 & 2147483647;
8718       var $2627=(($2626)|0)!=0;
8719       if ($2627) { __label__ = 96; break; } else { __label__ = 93; break; }
8720     case 93:
8721       var $2629=$st;
8722       var $2630=(($2629+4)|0);
8723       var $2631=$2630;
8724       var $2632=HEAP16[(($2631)>>1)];
8725       var $2633=(($2632 << 16) >> 16);
8726       var $2634=((($2633)-(1))|0);
8727       var $2635=$st;
8728       var $2636=(($2635+($2634<<3))|0);
8729       $st=$2636;
8730       var $2637=$jumpcount;
8731       var $2638=((($2637)+(1))|0);
8732       $jumpcount=$2638;
8733       var $2639=$5;
8734       var $2640=(($2638)|0) >= (($2639)|0);
8735       if ($2640) { __label__ = 94; break; } else { __label__ = 95; break; }
8736     case 94:
8737       var $2642=$2;
8738       var $2643=$2;
8739       var $2644=(($2643)|0);
8740       var $2645=HEAP32[(($2644)>>2)];
8741       var $2646=$jumpcount;
8742       _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));
8743       __label__ = 95; break;
8744     case 95:
8745       __label__ = 96; break;
8746     case 96:
8747       __label__ = 124; break;
8748     case 97:
8749       var $2650=$st;
8750       var $2651=(($2650)|0);
8751       var $2652=HEAP16[(($2651)>>1)];
8752       var $2653=(($2652)&65535);
8753       var $2654=((($2653)-(51))|0);
8754       var $2655=$2;
8755       var $2656=(($2655+184)|0);
8756       HEAP32[(($2656)>>2)]=$2654;
8757       var $2657=$2;
8758       var $2658=(($2657+64)|0);
8759       var $2659=HEAP32[(($2658)>>2)];
8760       var $2660=$st;
8761       var $2661=(($2660+2)|0);
8762       var $2662=$2661;
8763       var $2663=HEAP16[(($2662)>>1)];
8764       var $2664=(($2663)&65535);
8765       var $2665=(($2659+($2664<<2))|0);
8766       var $2666=$2665;
8767       var $2667=$2666;
8768       var $2668=HEAP32[(($2667)>>2)];
8769       var $2669=(($2668)|0)!=0;
8770       if ($2669) { __label__ = 99; break; } else { __label__ = 98; break; }
8771     case 98:
8772       var $2671=$2;
8773       var $2672=$2;
8774       var $2673=(($2672)|0);
8775       var $2674=HEAP32[(($2673)>>2)];
8776       _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));
8777       __label__ = 99; break;
8778     case 99:
8779       var $2676=$2;
8780       var $2677=(($2676+64)|0);
8781       var $2678=HEAP32[(($2677)>>2)];
8782       var $2679=$st;
8783       var $2680=(($2679+2)|0);
8784       var $2681=$2680;
8785       var $2682=HEAP16[(($2681)>>1)];
8786       var $2683=(($2682)&65535);
8787       var $2684=(($2678+($2683<<2))|0);
8788       var $2685=$2684;
8789       var $2686=$2685;
8790       var $2687=HEAP32[(($2686)>>2)];
8791       var $2688=(($2687)|0)!=0;
8792       if ($2688) { __label__ = 100; break; } else { __label__ = 101; break; }
8793     case 100:
8794       var $2690=$2;
8795       var $2691=(($2690+64)|0);
8796       var $2692=HEAP32[(($2691)>>2)];
8797       var $2693=$st;
8798       var $2694=(($2693+2)|0);
8799       var $2695=$2694;
8800       var $2696=HEAP16[(($2695)>>1)];
8801       var $2697=(($2696)&65535);
8802       var $2698=(($2692+($2697<<2))|0);
8803       var $2699=$2698;
8804       var $2700=$2699;
8805       var $2701=HEAP32[(($2700)>>2)];
8806       var $2702=$2;
8807       var $2703=(($2702+44)|0);
8808       var $2704=HEAP32[(($2703)>>2)];
8809       var $2705=(($2701)>>>0) >= (($2704)>>>0);
8810       if ($2705) { __label__ = 101; break; } else { __label__ = 102; break; }
8811     case 101:
8812       var $2707=$2;
8813       var $2708=$2;
8814       var $2709=(($2708)|0);
8815       var $2710=HEAP32[(($2709)>>2)];
8816       _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));
8817       __label__ = 488; break;
8818     case 102:
8819       var $2712=$2;
8820       var $2713=(($2712+64)|0);
8821       var $2714=HEAP32[(($2713)>>2)];
8822       var $2715=$st;
8823       var $2716=(($2715+2)|0);
8824       var $2717=$2716;
8825       var $2718=HEAP16[(($2717)>>1)];
8826       var $2719=(($2718)&65535);
8827       var $2720=(($2714+($2719<<2))|0);
8828       var $2721=$2720;
8829       var $2722=$2721;
8830       var $2723=HEAP32[(($2722)>>2)];
8831       var $2724=$2;
8832       var $2725=(($2724+40)|0);
8833       var $2726=HEAP32[(($2725)>>2)];
8834       var $2727=(($2726+($2723)*(36))|0);
8835       $newf=$2727;
8836       var $2728=$newf;
8837       var $2729=(($2728+12)|0);
8838       var $2730=HEAP32[(($2729)>>2)];
8839       var $2731=((($2730)+(1))|0);
8840       HEAP32[(($2729)>>2)]=$2731;
8841       var $2732=$st;
8842       var $2733=$2;
8843       var $2734=(($2733+4)|0);
8844       var $2735=HEAP32[(($2734)>>2)];
8845       var $2736=$2732;
8846       var $2737=$2735;
8847       var $2738=((($2736)-($2737))|0);
8848       var $2739=((((($2738)|0))/(8))&-1);
8849       var $2740=((($2739)+(1))|0);
8850       var $2741=$2;
8851       var $2742=(($2741+176)|0);
8852       HEAP32[(($2742)>>2)]=$2740;
8853       var $2743=$newf;
8854       var $2744=(($2743)|0);
8855       var $2745=HEAP32[(($2744)>>2)];
8856       var $2746=(($2745)|0) < 0;
8857       if ($2746) { __label__ = 103; break; } else { __label__ = 108; break; }
8858     case 103:
8859       var $2748=$newf;
8860       var $2749=(($2748)|0);
8861       var $2750=HEAP32[(($2749)>>2)];
8862       var $2751=(((-$2750))|0);
8863       $builtinnumber=$2751;
8864       var $2752=$builtinnumber;
8865       var $2753=$2;
8866       var $2754=(($2753+132)|0);
8867       var $2755=HEAP32[(($2754)>>2)];
8868       var $2756=(($2752)>>>0) < (($2755)>>>0);
8869       if ($2756) { __label__ = 104; break; } else { __label__ = 106; break; }
8870     case 104:
8871       var $2758=$builtinnumber;
8872       var $2759=$2;
8873       var $2760=(($2759+128)|0);
8874       var $2761=HEAP32[(($2760)>>2)];
8875       var $2762=(($2761+($2758<<2))|0);
8876       var $2763=HEAP32[(($2762)>>2)];
8877       var $2764=(($2763)|0)!=0;
8878       if ($2764) { __label__ = 105; break; } else { __label__ = 106; break; }
8879     case 105:
8880       var $2766=$builtinnumber;
8881       var $2767=$2;
8882       var $2768=(($2767+128)|0);
8883       var $2769=HEAP32[(($2768)>>2)];
8884       var $2770=(($2769+($2766<<2))|0);
8885       var $2771=HEAP32[(($2770)>>2)];
8886       var $2772=$2;
8887       var $2773=FUNCTION_TABLE[$2771]($2772);
8888       __label__ = 107; break;
8889     case 106:
8890       var $2775=$2;
8891       var $2776=$builtinnumber;
8892       var $2777=$2;
8893       var $2778=(($2777)|0);
8894       var $2779=HEAP32[(($2778)>>2)];
8895       _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));
8896       __label__ = 107; break;
8897     case 107:
8898       __label__ = 109; break;
8899     case 108:
8900       var $2782=$2;
8901       var $2783=(($2782+4)|0);
8902       var $2784=HEAP32[(($2783)>>2)];
8903       var $2785=$2;
8904       var $2786=$newf;
8905       var $2787=_prog_enterfunction($2785, $2786);
8906       var $2788=(($2784+($2787<<3))|0);
8907       var $2789=((($2788)-(8))|0);
8908       $st=$2789;
8909       __label__ = 109; break;
8910     case 109:
8911       var $2791=$2;
8912       var $2792=(($2791+112)|0);
8913       var $2793=HEAP32[(($2792)>>2)];
8914       var $2794=(($2793)|0)!=0;
8915       if ($2794) { __label__ = 110; break; } else { __label__ = 111; break; }
8916     case 110:
8917       __label__ = 488; break;
8918     case 111:
8919       __label__ = 124; break;
8920     case 112:
8921       var $2798=$2;
8922       var $2799=$2;
8923       var $2800=(($2799)|0);
8924       var $2801=HEAP32[(($2800)>>2)];
8925       _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));
8926       __label__ = 124; break;
8927     case 113:
8928       var $2803=$st;
8929       var $2804=(($2803+2)|0);
8930       var $2805=$2804;
8931       var $2806=HEAP16[(($2805)>>1)];
8932       var $2807=(($2806 << 16) >> 16);
8933       var $2808=((($2807)-(1))|0);
8934       var $2809=$st;
8935       var $2810=(($2809+($2808<<3))|0);
8936       $st=$2810;
8937       var $2811=$jumpcount;
8938       var $2812=((($2811)+(1))|0);
8939       $jumpcount=$2812;
8940       var $2813=(($2812)|0)==10000000;
8941       if ($2813) { __label__ = 114; break; } else { __label__ = 115; break; }
8942     case 114:
8943       var $2815=$2;
8944       var $2816=$2;
8945       var $2817=(($2816)|0);
8946       var $2818=HEAP32[(($2817)>>2)];
8947       var $2819=$jumpcount;
8948       _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));
8949       __label__ = 115; break;
8950     case 115:
8951       __label__ = 124; break;
8952     case 116:
8953       var $2822=$2;
8954       var $2823=(($2822+64)|0);
8955       var $2824=HEAP32[(($2823)>>2)];
8956       var $2825=$st;
8957       var $2826=(($2825+2)|0);
8958       var $2827=$2826;
8959       var $2828=HEAP16[(($2827)>>1)];
8960       var $2829=(($2828)&65535);
8961       var $2830=(($2824+($2829<<2))|0);
8962       var $2831=$2830;
8963       var $2832=$2831;
8964       var $2833=HEAP32[(($2832)>>2)];
8965       var $2834=$2833 & 2147483647;
8966       var $2835=(($2834)|0)!=0;
8967       if ($2835) { __label__ = 117; break; } else { var $2852 = 0;__label__ = 118; break; }
8968     case 117:
8969       var $2837=$2;
8970       var $2838=(($2837+64)|0);
8971       var $2839=HEAP32[(($2838)>>2)];
8972       var $2840=$st;
8973       var $2841=(($2840+4)|0);
8974       var $2842=$2841;
8975       var $2843=HEAP16[(($2842)>>1)];
8976       var $2844=(($2843)&65535);
8977       var $2845=(($2839+($2844<<2))|0);
8978       var $2846=$2845;
8979       var $2847=$2846;
8980       var $2848=HEAP32[(($2847)>>2)];
8981       var $2849=$2848 & 2147483647;
8982       var $2850=(($2849)|0)!=0;
8983       var $2852 = $2850;__label__ = 118; break;
8984     case 118:
8985       var $2852;
8986       var $2853=(($2852)&1);
8987       var $2854=(($2853)|0);
8988       var $2855=$2;
8989       var $2856=(($2855+64)|0);
8990       var $2857=HEAP32[(($2856)>>2)];
8991       var $2858=$st;
8992       var $2859=(($2858+6)|0);
8993       var $2860=$2859;
8994       var $2861=HEAP16[(($2860)>>1)];
8995       var $2862=(($2861)&65535);
8996       var $2863=(($2857+($2862<<2))|0);
8997       var $2864=$2863;
8998       var $2865=$2864;
8999       HEAPF32[(($2865)>>2)]=$2854;
9000       __label__ = 124; break;
9001     case 119:
9002       var $2867=$2;
9003       var $2868=(($2867+64)|0);
9004       var $2869=HEAP32[(($2868)>>2)];
9005       var $2870=$st;
9006       var $2871=(($2870+2)|0);
9007       var $2872=$2871;
9008       var $2873=HEAP16[(($2872)>>1)];
9009       var $2874=(($2873)&65535);
9010       var $2875=(($2869+($2874<<2))|0);
9011       var $2876=$2875;
9012       var $2877=$2876;
9013       var $2878=HEAP32[(($2877)>>2)];
9014       var $2879=$2878 & 2147483647;
9015       var $2880=(($2879)|0)!=0;
9016       if ($2880) { var $2897 = 1;__label__ = 121; break; } else { __label__ = 120; break; }
9017     case 120:
9018       var $2882=$2;
9019       var $2883=(($2882+64)|0);
9020       var $2884=HEAP32[(($2883)>>2)];
9021       var $2885=$st;
9022       var $2886=(($2885+4)|0);
9023       var $2887=$2886;
9024       var $2888=HEAP16[(($2887)>>1)];
9025       var $2889=(($2888)&65535);
9026       var $2890=(($2884+($2889<<2))|0);
9027       var $2891=$2890;
9028       var $2892=$2891;
9029       var $2893=HEAP32[(($2892)>>2)];
9030       var $2894=$2893 & 2147483647;
9031       var $2895=(($2894)|0)!=0;
9032       var $2897 = $2895;__label__ = 121; break;
9033     case 121:
9034       var $2897;
9035       var $2898=(($2897)&1);
9036       var $2899=(($2898)|0);
9037       var $2900=$2;
9038       var $2901=(($2900+64)|0);
9039       var $2902=HEAP32[(($2901)>>2)];
9040       var $2903=$st;
9041       var $2904=(($2903+6)|0);
9042       var $2905=$2904;
9043       var $2906=HEAP16[(($2905)>>1)];
9044       var $2907=(($2906)&65535);
9045       var $2908=(($2902+($2907<<2))|0);
9046       var $2909=$2908;
9047       var $2910=$2909;
9048       HEAPF32[(($2910)>>2)]=$2899;
9049       __label__ = 124; break;
9050     case 122:
9051       var $2912=$2;
9052       var $2913=(($2912+64)|0);
9053       var $2914=HEAP32[(($2913)>>2)];
9054       var $2915=$st;
9055       var $2916=(($2915+2)|0);
9056       var $2917=$2916;
9057       var $2918=HEAP16[(($2917)>>1)];
9058       var $2919=(($2918)&65535);
9059       var $2920=(($2914+($2919<<2))|0);
9060       var $2921=$2920;
9061       var $2922=$2921;
9062       var $2923=HEAPF32[(($2922)>>2)];
9063       var $2924=(($2923)&-1);
9064       var $2925=$2;
9065       var $2926=(($2925+64)|0);
9066       var $2927=HEAP32[(($2926)>>2)];
9067       var $2928=$st;
9068       var $2929=(($2928+4)|0);
9069       var $2930=$2929;
9070       var $2931=HEAP16[(($2930)>>1)];
9071       var $2932=(($2931)&65535);
9072       var $2933=(($2927+($2932<<2))|0);
9073       var $2934=$2933;
9074       var $2935=$2934;
9075       var $2936=HEAPF32[(($2935)>>2)];
9076       var $2937=(($2936)&-1);
9077       var $2938=$2924 & $2937;
9078       var $2939=(($2938)|0);
9079       var $2940=$2;
9080       var $2941=(($2940+64)|0);
9081       var $2942=HEAP32[(($2941)>>2)];
9082       var $2943=$st;
9083       var $2944=(($2943+6)|0);
9084       var $2945=$2944;
9085       var $2946=HEAP16[(($2945)>>1)];
9086       var $2947=(($2946)&65535);
9087       var $2948=(($2942+($2947<<2))|0);
9088       var $2949=$2948;
9089       var $2950=$2949;
9090       HEAPF32[(($2950)>>2)]=$2939;
9091       __label__ = 124; break;
9092     case 123:
9093       var $2952=$2;
9094       var $2953=(($2952+64)|0);
9095       var $2954=HEAP32[(($2953)>>2)];
9096       var $2955=$st;
9097       var $2956=(($2955+2)|0);
9098       var $2957=$2956;
9099       var $2958=HEAP16[(($2957)>>1)];
9100       var $2959=(($2958)&65535);
9101       var $2960=(($2954+($2959<<2))|0);
9102       var $2961=$2960;
9103       var $2962=$2961;
9104       var $2963=HEAPF32[(($2962)>>2)];
9105       var $2964=(($2963)&-1);
9106       var $2965=$2;
9107       var $2966=(($2965+64)|0);
9108       var $2967=HEAP32[(($2966)>>2)];
9109       var $2968=$st;
9110       var $2969=(($2968+4)|0);
9111       var $2970=$2969;
9112       var $2971=HEAP16[(($2970)>>1)];
9113       var $2972=(($2971)&65535);
9114       var $2973=(($2967+($2972<<2))|0);
9115       var $2974=$2973;
9116       var $2975=$2974;
9117       var $2976=HEAPF32[(($2975)>>2)];
9118       var $2977=(($2976)&-1);
9119       var $2978=$2964 | $2977;
9120       var $2979=(($2978)|0);
9121       var $2980=$2;
9122       var $2981=(($2980+64)|0);
9123       var $2982=HEAP32[(($2981)>>2)];
9124       var $2983=$st;
9125       var $2984=(($2983+6)|0);
9126       var $2985=$2984;
9127       var $2986=HEAP16[(($2985)>>1)];
9128       var $2987=(($2986)&65535);
9129       var $2988=(($2982+($2987<<2))|0);
9130       var $2989=$2988;
9131       var $2990=$2989;
9132       HEAPF32[(($2990)>>2)]=$2979;
9133       __label__ = 124; break;
9134     case 124:
9135       __label__ = 5; break;
9136     case 125:
9137       __label__ = 126; break;
9138     case 126:
9139       var $2994=$st;
9140       var $2995=(($2994+8)|0);
9141       $st=$2995;
9142       var $2996=$2;
9143       var $2997=$st;
9144       _prog_print_statement($2996, $2997);
9145       var $2998=$st;
9146       var $2999=(($2998)|0);
9147       var $3000=HEAP16[(($2999)>>1)];
9148       var $3001=(($3000)&65535);
9149       if ((($3001)|0) == 0 || (($3001)|0) == 43) {
9150         __label__ = 128; break;
9151       }
9152       else if ((($3001)|0) == 1) {
9153         __label__ = 131; break;
9154       }
9155       else if ((($3001)|0) == 2) {
9156         __label__ = 132; break;
9157       }
9158       else if ((($3001)|0) == 3) {
9159         __label__ = 133; break;
9160       }
9161       else if ((($3001)|0) == 4) {
9162         __label__ = 134; break;
9163       }
9164       else if ((($3001)|0) == 5) {
9165         __label__ = 135; break;
9166       }
9167       else if ((($3001)|0) == 6) {
9168         __label__ = 139; break;
9169       }
9170       else if ((($3001)|0) == 7) {
9171         __label__ = 140; break;
9172       }
9173       else if ((($3001)|0) == 8) {
9174         __label__ = 141; break;
9175       }
9176       else if ((($3001)|0) == 9) {
9177         __label__ = 142; break;
9178       }
9179       else if ((($3001)|0) == 10) {
9180         __label__ = 143; break;
9181       }
9182       else if ((($3001)|0) == 11) {
9183         __label__ = 144; break;
9184       }
9185       else if ((($3001)|0) == 12) {
9186         __label__ = 148; break;
9187       }
9188       else if ((($3001)|0) == 13) {
9189         __label__ = 149; break;
9190       }
9191       else if ((($3001)|0) == 14) {
9192         __label__ = 150; break;
9193       }
9194       else if ((($3001)|0) == 15) {
9195         __label__ = 151; break;
9196       }
9197       else if ((($3001)|0) == 16) {
9198         __label__ = 152; break;
9199       }
9200       else if ((($3001)|0) == 17) {
9201         __label__ = 156; break;
9202       }
9203       else if ((($3001)|0) == 18) {
9204         __label__ = 157; break;
9205       }
9206       else if ((($3001)|0) == 19) {
9207         __label__ = 158; break;
9208       }
9209       else if ((($3001)|0) == 20) {
9210         __label__ = 159; break;
9211       }
9212       else if ((($3001)|0) == 21) {
9213         __label__ = 160; break;
9214       }
9215       else if ((($3001)|0) == 22) {
9216         __label__ = 161; break;
9217       }
9218       else if ((($3001)|0) == 23) {
9219         __label__ = 162; break;
9220       }
9221       else if ((($3001)|0) == 24 || (($3001)|0) == 26 || (($3001)|0) == 28 || (($3001)|0) == 27 || (($3001)|0) == 29) {
9222         __label__ = 163; break;
9223       }
9224       else if ((($3001)|0) == 25) {
9225         __label__ = 169; break;
9226       }
9227       else if ((($3001)|0) == 30) {
9228         __label__ = 176; break;
9229       }
9230       else if ((($3001)|0) == 31 || (($3001)|0) == 33 || (($3001)|0) == 34 || (($3001)|0) == 35 || (($3001)|0) == 36) {
9231         __label__ = 182; break;
9232       }
9233       else if ((($3001)|0) == 32) {
9234         __label__ = 183; break;
9235       }
9236       else if ((($3001)|0) == 37 || (($3001)|0) == 39 || (($3001)|0) == 40 || (($3001)|0) == 41 || (($3001)|0) == 42) {
9237         __label__ = 184; break;
9238       }
9239       else if ((($3001)|0) == 38) {
9240         __label__ = 191; break;
9241       }
9242       else if ((($3001)|0) == 44) {
9243         __label__ = 198; break;
9244       }
9245       else if ((($3001)|0) == 45) {
9246         __label__ = 199; break;
9247       }
9248       else if ((($3001)|0) == 46) {
9249         __label__ = 203; break;
9250       }
9251       else if ((($3001)|0) == 47) {
9252         __label__ = 206; break;
9253       }
9254       else if ((($3001)|0) == 48) {
9255         __label__ = 207; break;
9256       }
9257       else if ((($3001)|0) == 49) {
9258         __label__ = 208; break;
9259       }
9260       else if ((($3001)|0) == 50) {
9261         __label__ = 213; break;
9262       }
9263       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) {
9264         __label__ = 218; break;
9265       }
9266       else if ((($3001)|0) == 60) {
9267         __label__ = 233; break;
9268       }
9269       else if ((($3001)|0) == 61) {
9270         __label__ = 234; break;
9271       }
9272       else if ((($3001)|0) == 62) {
9273         __label__ = 237; break;
9274       }
9275       else if ((($3001)|0) == 63) {
9276         __label__ = 240; break;
9277       }
9278       else if ((($3001)|0) == 64) {
9279         __label__ = 243; break;
9280       }
9281       else if ((($3001)|0) == 65) {
9282         __label__ = 244; break;
9283       }
9284       else {
9285       __label__ = 127; break;
9286       }
9287
9288     case 127:
9289       var $3003=$2;
9290       var $3004=$2;
9291       var $3005=(($3004)|0);
9292       var $3006=HEAP32[(($3005)>>2)];
9293       _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));
9294       __label__ = 488; break;
9295     case 128:
9296       var $3008=$2;
9297       var $3009=(($3008+64)|0);
9298       var $3010=HEAP32[(($3009)>>2)];
9299       var $3011=$st;
9300       var $3012=(($3011+2)|0);
9301       var $3013=$3012;
9302       var $3014=HEAP16[(($3013)>>1)];
9303       var $3015=(($3014)&65535);
9304       var $3016=(($3010+($3015<<2))|0);
9305       var $3017=$3016;
9306       var $3018=$3017;
9307       var $3019=(($3018)|0);
9308       var $3020=HEAP32[(($3019)>>2)];
9309       var $3021=$2;
9310       var $3022=(($3021+64)|0);
9311       var $3023=HEAP32[(($3022)>>2)];
9312       var $3024=(($3023+4)|0);
9313       var $3025=$3024;
9314       var $3026=$3025;
9315       var $3027=(($3026)|0);
9316       HEAP32[(($3027)>>2)]=$3020;
9317       var $3028=$2;
9318       var $3029=(($3028+64)|0);
9319       var $3030=HEAP32[(($3029)>>2)];
9320       var $3031=$st;
9321       var $3032=(($3031+2)|0);
9322       var $3033=$3032;
9323       var $3034=HEAP16[(($3033)>>1)];
9324       var $3035=(($3034)&65535);
9325       var $3036=(($3030+($3035<<2))|0);
9326       var $3037=$3036;
9327       var $3038=$3037;
9328       var $3039=(($3038+4)|0);
9329       var $3040=HEAP32[(($3039)>>2)];
9330       var $3041=$2;
9331       var $3042=(($3041+64)|0);
9332       var $3043=HEAP32[(($3042)>>2)];
9333       var $3044=(($3043+4)|0);
9334       var $3045=$3044;
9335       var $3046=$3045;
9336       var $3047=(($3046+4)|0);
9337       HEAP32[(($3047)>>2)]=$3040;
9338       var $3048=$2;
9339       var $3049=(($3048+64)|0);
9340       var $3050=HEAP32[(($3049)>>2)];
9341       var $3051=$st;
9342       var $3052=(($3051+2)|0);
9343       var $3053=$3052;
9344       var $3054=HEAP16[(($3053)>>1)];
9345       var $3055=(($3054)&65535);
9346       var $3056=(($3050+($3055<<2))|0);
9347       var $3057=$3056;
9348       var $3058=$3057;
9349       var $3059=(($3058+8)|0);
9350       var $3060=HEAP32[(($3059)>>2)];
9351       var $3061=$2;
9352       var $3062=(($3061+64)|0);
9353       var $3063=HEAP32[(($3062)>>2)];
9354       var $3064=(($3063+4)|0);
9355       var $3065=$3064;
9356       var $3066=$3065;
9357       var $3067=(($3066+8)|0);
9358       HEAP32[(($3067)>>2)]=$3060;
9359       var $3068=$2;
9360       var $3069=(($3068+4)|0);
9361       var $3070=HEAP32[(($3069)>>2)];
9362       var $3071=$2;
9363       var $3072=_prog_leavefunction($3071);
9364       var $3073=(($3070+($3072<<3))|0);
9365       $st=$3073;
9366       var $3074=$2;
9367       var $3075=(($3074+168)|0);
9368       var $3076=HEAP32[(($3075)>>2)];
9369       var $3077=(($3076)|0)!=0;
9370       if ($3077) { __label__ = 130; break; } else { __label__ = 129; break; }
9371     case 129:
9372       __label__ = 488; break;
9373     case 130:
9374       __label__ = 245; break;
9375     case 131:
9376       var $3081=$2;
9377       var $3082=(($3081+64)|0);
9378       var $3083=HEAP32[(($3082)>>2)];
9379       var $3084=$st;
9380       var $3085=(($3084+2)|0);
9381       var $3086=$3085;
9382       var $3087=HEAP16[(($3086)>>1)];
9383       var $3088=(($3087)&65535);
9384       var $3089=(($3083+($3088<<2))|0);
9385       var $3090=$3089;
9386       var $3091=$3090;
9387       var $3092=HEAPF32[(($3091)>>2)];
9388       var $3093=$2;
9389       var $3094=(($3093+64)|0);
9390       var $3095=HEAP32[(($3094)>>2)];
9391       var $3096=$st;
9392       var $3097=(($3096+4)|0);
9393       var $3098=$3097;
9394       var $3099=HEAP16[(($3098)>>1)];
9395       var $3100=(($3099)&65535);
9396       var $3101=(($3095+($3100<<2))|0);
9397       var $3102=$3101;
9398       var $3103=$3102;
9399       var $3104=HEAPF32[(($3103)>>2)];
9400       var $3105=($3092)*($3104);
9401       var $3106=$2;
9402       var $3107=(($3106+64)|0);
9403       var $3108=HEAP32[(($3107)>>2)];
9404       var $3109=$st;
9405       var $3110=(($3109+6)|0);
9406       var $3111=$3110;
9407       var $3112=HEAP16[(($3111)>>1)];
9408       var $3113=(($3112)&65535);
9409       var $3114=(($3108+($3113<<2))|0);
9410       var $3115=$3114;
9411       var $3116=$3115;
9412       HEAPF32[(($3116)>>2)]=$3105;
9413       __label__ = 245; break;
9414     case 132:
9415       var $3118=$2;
9416       var $3119=(($3118+64)|0);
9417       var $3120=HEAP32[(($3119)>>2)];
9418       var $3121=$st;
9419       var $3122=(($3121+2)|0);
9420       var $3123=$3122;
9421       var $3124=HEAP16[(($3123)>>1)];
9422       var $3125=(($3124)&65535);
9423       var $3126=(($3120+($3125<<2))|0);
9424       var $3127=$3126;
9425       var $3128=$3127;
9426       var $3129=(($3128)|0);
9427       var $3130=HEAPF32[(($3129)>>2)];
9428       var $3131=$2;
9429       var $3132=(($3131+64)|0);
9430       var $3133=HEAP32[(($3132)>>2)];
9431       var $3134=$st;
9432       var $3135=(($3134+4)|0);
9433       var $3136=$3135;
9434       var $3137=HEAP16[(($3136)>>1)];
9435       var $3138=(($3137)&65535);
9436       var $3139=(($3133+($3138<<2))|0);
9437       var $3140=$3139;
9438       var $3141=$3140;
9439       var $3142=(($3141)|0);
9440       var $3143=HEAPF32[(($3142)>>2)];
9441       var $3144=($3130)*($3143);
9442       var $3145=$2;
9443       var $3146=(($3145+64)|0);
9444       var $3147=HEAP32[(($3146)>>2)];
9445       var $3148=$st;
9446       var $3149=(($3148+2)|0);
9447       var $3150=$3149;
9448       var $3151=HEAP16[(($3150)>>1)];
9449       var $3152=(($3151)&65535);
9450       var $3153=(($3147+($3152<<2))|0);
9451       var $3154=$3153;
9452       var $3155=$3154;
9453       var $3156=(($3155+4)|0);
9454       var $3157=HEAPF32[(($3156)>>2)];
9455       var $3158=$2;
9456       var $3159=(($3158+64)|0);
9457       var $3160=HEAP32[(($3159)>>2)];
9458       var $3161=$st;
9459       var $3162=(($3161+4)|0);
9460       var $3163=$3162;
9461       var $3164=HEAP16[(($3163)>>1)];
9462       var $3165=(($3164)&65535);
9463       var $3166=(($3160+($3165<<2))|0);
9464       var $3167=$3166;
9465       var $3168=$3167;
9466       var $3169=(($3168+4)|0);
9467       var $3170=HEAPF32[(($3169)>>2)];
9468       var $3171=($3157)*($3170);
9469       var $3172=($3144)+($3171);
9470       var $3173=$2;
9471       var $3174=(($3173+64)|0);
9472       var $3175=HEAP32[(($3174)>>2)];
9473       var $3176=$st;
9474       var $3177=(($3176+2)|0);
9475       var $3178=$3177;
9476       var $3179=HEAP16[(($3178)>>1)];
9477       var $3180=(($3179)&65535);
9478       var $3181=(($3175+($3180<<2))|0);
9479       var $3182=$3181;
9480       var $3183=$3182;
9481       var $3184=(($3183+8)|0);
9482       var $3185=HEAPF32[(($3184)>>2)];
9483       var $3186=$2;
9484       var $3187=(($3186+64)|0);
9485       var $3188=HEAP32[(($3187)>>2)];
9486       var $3189=$st;
9487       var $3190=(($3189+4)|0);
9488       var $3191=$3190;
9489       var $3192=HEAP16[(($3191)>>1)];
9490       var $3193=(($3192)&65535);
9491       var $3194=(($3188+($3193<<2))|0);
9492       var $3195=$3194;
9493       var $3196=$3195;
9494       var $3197=(($3196+8)|0);
9495       var $3198=HEAPF32[(($3197)>>2)];
9496       var $3199=($3185)*($3198);
9497       var $3200=($3172)+($3199);
9498       var $3201=$2;
9499       var $3202=(($3201+64)|0);
9500       var $3203=HEAP32[(($3202)>>2)];
9501       var $3204=$st;
9502       var $3205=(($3204+6)|0);
9503       var $3206=$3205;
9504       var $3207=HEAP16[(($3206)>>1)];
9505       var $3208=(($3207)&65535);
9506       var $3209=(($3203+($3208<<2))|0);
9507       var $3210=$3209;
9508       var $3211=$3210;
9509       HEAPF32[(($3211)>>2)]=$3200;
9510       __label__ = 245; break;
9511     case 133:
9512       var $3213=$2;
9513       var $3214=(($3213+64)|0);
9514       var $3215=HEAP32[(($3214)>>2)];
9515       var $3216=$st;
9516       var $3217=(($3216+2)|0);
9517       var $3218=$3217;
9518       var $3219=HEAP16[(($3218)>>1)];
9519       var $3220=(($3219)&65535);
9520       var $3221=(($3215+($3220<<2))|0);
9521       var $3222=$3221;
9522       var $3223=$3222;
9523       var $3224=HEAPF32[(($3223)>>2)];
9524       var $3225=$2;
9525       var $3226=(($3225+64)|0);
9526       var $3227=HEAP32[(($3226)>>2)];
9527       var $3228=$st;
9528       var $3229=(($3228+4)|0);
9529       var $3230=$3229;
9530       var $3231=HEAP16[(($3230)>>1)];
9531       var $3232=(($3231)&65535);
9532       var $3233=(($3227+($3232<<2))|0);
9533       var $3234=$3233;
9534       var $3235=$3234;
9535       var $3236=(($3235)|0);
9536       var $3237=HEAPF32[(($3236)>>2)];
9537       var $3238=($3224)*($3237);
9538       var $3239=$2;
9539       var $3240=(($3239+64)|0);
9540       var $3241=HEAP32[(($3240)>>2)];
9541       var $3242=$st;
9542       var $3243=(($3242+6)|0);
9543       var $3244=$3243;
9544       var $3245=HEAP16[(($3244)>>1)];
9545       var $3246=(($3245)&65535);
9546       var $3247=(($3241+($3246<<2))|0);
9547       var $3248=$3247;
9548       var $3249=$3248;
9549       var $3250=(($3249)|0);
9550       HEAPF32[(($3250)>>2)]=$3238;
9551       var $3251=$2;
9552       var $3252=(($3251+64)|0);
9553       var $3253=HEAP32[(($3252)>>2)];
9554       var $3254=$st;
9555       var $3255=(($3254+2)|0);
9556       var $3256=$3255;
9557       var $3257=HEAP16[(($3256)>>1)];
9558       var $3258=(($3257)&65535);
9559       var $3259=(($3253+($3258<<2))|0);
9560       var $3260=$3259;
9561       var $3261=$3260;
9562       var $3262=HEAPF32[(($3261)>>2)];
9563       var $3263=$2;
9564       var $3264=(($3263+64)|0);
9565       var $3265=HEAP32[(($3264)>>2)];
9566       var $3266=$st;
9567       var $3267=(($3266+4)|0);
9568       var $3268=$3267;
9569       var $3269=HEAP16[(($3268)>>1)];
9570       var $3270=(($3269)&65535);
9571       var $3271=(($3265+($3270<<2))|0);
9572       var $3272=$3271;
9573       var $3273=$3272;
9574       var $3274=(($3273+4)|0);
9575       var $3275=HEAPF32[(($3274)>>2)];
9576       var $3276=($3262)*($3275);
9577       var $3277=$2;
9578       var $3278=(($3277+64)|0);
9579       var $3279=HEAP32[(($3278)>>2)];
9580       var $3280=$st;
9581       var $3281=(($3280+6)|0);
9582       var $3282=$3281;
9583       var $3283=HEAP16[(($3282)>>1)];
9584       var $3284=(($3283)&65535);
9585       var $3285=(($3279+($3284<<2))|0);
9586       var $3286=$3285;
9587       var $3287=$3286;
9588       var $3288=(($3287+4)|0);
9589       HEAPF32[(($3288)>>2)]=$3276;
9590       var $3289=$2;
9591       var $3290=(($3289+64)|0);
9592       var $3291=HEAP32[(($3290)>>2)];
9593       var $3292=$st;
9594       var $3293=(($3292+2)|0);
9595       var $3294=$3293;
9596       var $3295=HEAP16[(($3294)>>1)];
9597       var $3296=(($3295)&65535);
9598       var $3297=(($3291+($3296<<2))|0);
9599       var $3298=$3297;
9600       var $3299=$3298;
9601       var $3300=HEAPF32[(($3299)>>2)];
9602       var $3301=$2;
9603       var $3302=(($3301+64)|0);
9604       var $3303=HEAP32[(($3302)>>2)];
9605       var $3304=$st;
9606       var $3305=(($3304+4)|0);
9607       var $3306=$3305;
9608       var $3307=HEAP16[(($3306)>>1)];
9609       var $3308=(($3307)&65535);
9610       var $3309=(($3303+($3308<<2))|0);
9611       var $3310=$3309;
9612       var $3311=$3310;
9613       var $3312=(($3311+8)|0);
9614       var $3313=HEAPF32[(($3312)>>2)];
9615       var $3314=($3300)*($3313);
9616       var $3315=$2;
9617       var $3316=(($3315+64)|0);
9618       var $3317=HEAP32[(($3316)>>2)];
9619       var $3318=$st;
9620       var $3319=(($3318+6)|0);
9621       var $3320=$3319;
9622       var $3321=HEAP16[(($3320)>>1)];
9623       var $3322=(($3321)&65535);
9624       var $3323=(($3317+($3322<<2))|0);
9625       var $3324=$3323;
9626       var $3325=$3324;
9627       var $3326=(($3325+8)|0);
9628       HEAPF32[(($3326)>>2)]=$3314;
9629       __label__ = 245; break;
9630     case 134:
9631       var $3328=$2;
9632       var $3329=(($3328+64)|0);
9633       var $3330=HEAP32[(($3329)>>2)];
9634       var $3331=$st;
9635       var $3332=(($3331+4)|0);
9636       var $3333=$3332;
9637       var $3334=HEAP16[(($3333)>>1)];
9638       var $3335=(($3334)&65535);
9639       var $3336=(($3330+($3335<<2))|0);
9640       var $3337=$3336;
9641       var $3338=$3337;
9642       var $3339=HEAPF32[(($3338)>>2)];
9643       var $3340=$2;
9644       var $3341=(($3340+64)|0);
9645       var $3342=HEAP32[(($3341)>>2)];
9646       var $3343=$st;
9647       var $3344=(($3343+2)|0);
9648       var $3345=$3344;
9649       var $3346=HEAP16[(($3345)>>1)];
9650       var $3347=(($3346)&65535);
9651       var $3348=(($3342+($3347<<2))|0);
9652       var $3349=$3348;
9653       var $3350=$3349;
9654       var $3351=(($3350)|0);
9655       var $3352=HEAPF32[(($3351)>>2)];
9656       var $3353=($3339)*($3352);
9657       var $3354=$2;
9658       var $3355=(($3354+64)|0);
9659       var $3356=HEAP32[(($3355)>>2)];
9660       var $3357=$st;
9661       var $3358=(($3357+6)|0);
9662       var $3359=$3358;
9663       var $3360=HEAP16[(($3359)>>1)];
9664       var $3361=(($3360)&65535);
9665       var $3362=(($3356+($3361<<2))|0);
9666       var $3363=$3362;
9667       var $3364=$3363;
9668       var $3365=(($3364)|0);
9669       HEAPF32[(($3365)>>2)]=$3353;
9670       var $3366=$2;
9671       var $3367=(($3366+64)|0);
9672       var $3368=HEAP32[(($3367)>>2)];
9673       var $3369=$st;
9674       var $3370=(($3369+4)|0);
9675       var $3371=$3370;
9676       var $3372=HEAP16[(($3371)>>1)];
9677       var $3373=(($3372)&65535);
9678       var $3374=(($3368+($3373<<2))|0);
9679       var $3375=$3374;
9680       var $3376=$3375;
9681       var $3377=HEAPF32[(($3376)>>2)];
9682       var $3378=$2;
9683       var $3379=(($3378+64)|0);
9684       var $3380=HEAP32[(($3379)>>2)];
9685       var $3381=$st;
9686       var $3382=(($3381+2)|0);
9687       var $3383=$3382;
9688       var $3384=HEAP16[(($3383)>>1)];
9689       var $3385=(($3384)&65535);
9690       var $3386=(($3380+($3385<<2))|0);
9691       var $3387=$3386;
9692       var $3388=$3387;
9693       var $3389=(($3388+4)|0);
9694       var $3390=HEAPF32[(($3389)>>2)];
9695       var $3391=($3377)*($3390);
9696       var $3392=$2;
9697       var $3393=(($3392+64)|0);
9698       var $3394=HEAP32[(($3393)>>2)];
9699       var $3395=$st;
9700       var $3396=(($3395+6)|0);
9701       var $3397=$3396;
9702       var $3398=HEAP16[(($3397)>>1)];
9703       var $3399=(($3398)&65535);
9704       var $3400=(($3394+($3399<<2))|0);
9705       var $3401=$3400;
9706       var $3402=$3401;
9707       var $3403=(($3402+4)|0);
9708       HEAPF32[(($3403)>>2)]=$3391;
9709       var $3404=$2;
9710       var $3405=(($3404+64)|0);
9711       var $3406=HEAP32[(($3405)>>2)];
9712       var $3407=$st;
9713       var $3408=(($3407+4)|0);
9714       var $3409=$3408;
9715       var $3410=HEAP16[(($3409)>>1)];
9716       var $3411=(($3410)&65535);
9717       var $3412=(($3406+($3411<<2))|0);
9718       var $3413=$3412;
9719       var $3414=$3413;
9720       var $3415=HEAPF32[(($3414)>>2)];
9721       var $3416=$2;
9722       var $3417=(($3416+64)|0);
9723       var $3418=HEAP32[(($3417)>>2)];
9724       var $3419=$st;
9725       var $3420=(($3419+2)|0);
9726       var $3421=$3420;
9727       var $3422=HEAP16[(($3421)>>1)];
9728       var $3423=(($3422)&65535);
9729       var $3424=(($3418+($3423<<2))|0);
9730       var $3425=$3424;
9731       var $3426=$3425;
9732       var $3427=(($3426+8)|0);
9733       var $3428=HEAPF32[(($3427)>>2)];
9734       var $3429=($3415)*($3428);
9735       var $3430=$2;
9736       var $3431=(($3430+64)|0);
9737       var $3432=HEAP32[(($3431)>>2)];
9738       var $3433=$st;
9739       var $3434=(($3433+6)|0);
9740       var $3435=$3434;
9741       var $3436=HEAP16[(($3435)>>1)];
9742       var $3437=(($3436)&65535);
9743       var $3438=(($3432+($3437<<2))|0);
9744       var $3439=$3438;
9745       var $3440=$3439;
9746       var $3441=(($3440+8)|0);
9747       HEAPF32[(($3441)>>2)]=$3429;
9748       __label__ = 245; break;
9749     case 135:
9750       var $3443=$2;
9751       var $3444=(($3443+64)|0);
9752       var $3445=HEAP32[(($3444)>>2)];
9753       var $3446=$st;
9754       var $3447=(($3446+4)|0);
9755       var $3448=$3447;
9756       var $3449=HEAP16[(($3448)>>1)];
9757       var $3450=(($3449)&65535);
9758       var $3451=(($3445+($3450<<2))|0);
9759       var $3452=$3451;
9760       var $3453=$3452;
9761       var $3454=HEAPF32[(($3453)>>2)];
9762       var $3455=$3454 != 0;
9763       if ($3455) { __label__ = 136; break; } else { __label__ = 137; break; }
9764     case 136:
9765       var $3457=$2;
9766       var $3458=(($3457+64)|0);
9767       var $3459=HEAP32[(($3458)>>2)];
9768       var $3460=$st;
9769       var $3461=(($3460+2)|0);
9770       var $3462=$3461;
9771       var $3463=HEAP16[(($3462)>>1)];
9772       var $3464=(($3463)&65535);
9773       var $3465=(($3459+($3464<<2))|0);
9774       var $3466=$3465;
9775       var $3467=$3466;
9776       var $3468=HEAPF32[(($3467)>>2)];
9777       var $3469=$2;
9778       var $3470=(($3469+64)|0);
9779       var $3471=HEAP32[(($3470)>>2)];
9780       var $3472=$st;
9781       var $3473=(($3472+4)|0);
9782       var $3474=$3473;
9783       var $3475=HEAP16[(($3474)>>1)];
9784       var $3476=(($3475)&65535);
9785       var $3477=(($3471+($3476<<2))|0);
9786       var $3478=$3477;
9787       var $3479=$3478;
9788       var $3480=HEAPF32[(($3479)>>2)];
9789       var $3481=($3468)/($3480);
9790       var $3482=$2;
9791       var $3483=(($3482+64)|0);
9792       var $3484=HEAP32[(($3483)>>2)];
9793       var $3485=$st;
9794       var $3486=(($3485+6)|0);
9795       var $3487=$3486;
9796       var $3488=HEAP16[(($3487)>>1)];
9797       var $3489=(($3488)&65535);
9798       var $3490=(($3484+($3489<<2))|0);
9799       var $3491=$3490;
9800       var $3492=$3491;
9801       HEAPF32[(($3492)>>2)]=$3481;
9802       __label__ = 138; break;
9803     case 137:
9804       var $3494=$2;
9805       var $3495=(($3494+64)|0);
9806       var $3496=HEAP32[(($3495)>>2)];
9807       var $3497=$st;
9808       var $3498=(($3497+6)|0);
9809       var $3499=$3498;
9810       var $3500=HEAP16[(($3499)>>1)];
9811       var $3501=(($3500)&65535);
9812       var $3502=(($3496+($3501<<2))|0);
9813       var $3503=$3502;
9814       var $3504=$3503;
9815       HEAPF32[(($3504)>>2)]=0;
9816       __label__ = 138; break;
9817     case 138:
9818       __label__ = 245; break;
9819     case 139:
9820       var $3507=$2;
9821       var $3508=(($3507+64)|0);
9822       var $3509=HEAP32[(($3508)>>2)];
9823       var $3510=$st;
9824       var $3511=(($3510+2)|0);
9825       var $3512=$3511;
9826       var $3513=HEAP16[(($3512)>>1)];
9827       var $3514=(($3513)&65535);
9828       var $3515=(($3509+($3514<<2))|0);
9829       var $3516=$3515;
9830       var $3517=$3516;
9831       var $3518=HEAPF32[(($3517)>>2)];
9832       var $3519=$2;
9833       var $3520=(($3519+64)|0);
9834       var $3521=HEAP32[(($3520)>>2)];
9835       var $3522=$st;
9836       var $3523=(($3522+4)|0);
9837       var $3524=$3523;
9838       var $3525=HEAP16[(($3524)>>1)];
9839       var $3526=(($3525)&65535);
9840       var $3527=(($3521+($3526<<2))|0);
9841       var $3528=$3527;
9842       var $3529=$3528;
9843       var $3530=HEAPF32[(($3529)>>2)];
9844       var $3531=($3518)+($3530);
9845       var $3532=$2;
9846       var $3533=(($3532+64)|0);
9847       var $3534=HEAP32[(($3533)>>2)];
9848       var $3535=$st;
9849       var $3536=(($3535+6)|0);
9850       var $3537=$3536;
9851       var $3538=HEAP16[(($3537)>>1)];
9852       var $3539=(($3538)&65535);
9853       var $3540=(($3534+($3539<<2))|0);
9854       var $3541=$3540;
9855       var $3542=$3541;
9856       HEAPF32[(($3542)>>2)]=$3531;
9857       __label__ = 245; break;
9858     case 140:
9859       var $3544=$2;
9860       var $3545=(($3544+64)|0);
9861       var $3546=HEAP32[(($3545)>>2)];
9862       var $3547=$st;
9863       var $3548=(($3547+2)|0);
9864       var $3549=$3548;
9865       var $3550=HEAP16[(($3549)>>1)];
9866       var $3551=(($3550)&65535);
9867       var $3552=(($3546+($3551<<2))|0);
9868       var $3553=$3552;
9869       var $3554=$3553;
9870       var $3555=(($3554)|0);
9871       var $3556=HEAPF32[(($3555)>>2)];
9872       var $3557=$2;
9873       var $3558=(($3557+64)|0);
9874       var $3559=HEAP32[(($3558)>>2)];
9875       var $3560=$st;
9876       var $3561=(($3560+4)|0);
9877       var $3562=$3561;
9878       var $3563=HEAP16[(($3562)>>1)];
9879       var $3564=(($3563)&65535);
9880       var $3565=(($3559+($3564<<2))|0);
9881       var $3566=$3565;
9882       var $3567=$3566;
9883       var $3568=(($3567)|0);
9884       var $3569=HEAPF32[(($3568)>>2)];
9885       var $3570=($3556)+($3569);
9886       var $3571=$2;
9887       var $3572=(($3571+64)|0);
9888       var $3573=HEAP32[(($3572)>>2)];
9889       var $3574=$st;
9890       var $3575=(($3574+6)|0);
9891       var $3576=$3575;
9892       var $3577=HEAP16[(($3576)>>1)];
9893       var $3578=(($3577)&65535);
9894       var $3579=(($3573+($3578<<2))|0);
9895       var $3580=$3579;
9896       var $3581=$3580;
9897       var $3582=(($3581)|0);
9898       HEAPF32[(($3582)>>2)]=$3570;
9899       var $3583=$2;
9900       var $3584=(($3583+64)|0);
9901       var $3585=HEAP32[(($3584)>>2)];
9902       var $3586=$st;
9903       var $3587=(($3586+2)|0);
9904       var $3588=$3587;
9905       var $3589=HEAP16[(($3588)>>1)];
9906       var $3590=(($3589)&65535);
9907       var $3591=(($3585+($3590<<2))|0);
9908       var $3592=$3591;
9909       var $3593=$3592;
9910       var $3594=(($3593+4)|0);
9911       var $3595=HEAPF32[(($3594)>>2)];
9912       var $3596=$2;
9913       var $3597=(($3596+64)|0);
9914       var $3598=HEAP32[(($3597)>>2)];
9915       var $3599=$st;
9916       var $3600=(($3599+4)|0);
9917       var $3601=$3600;
9918       var $3602=HEAP16[(($3601)>>1)];
9919       var $3603=(($3602)&65535);
9920       var $3604=(($3598+($3603<<2))|0);
9921       var $3605=$3604;
9922       var $3606=$3605;
9923       var $3607=(($3606+4)|0);
9924       var $3608=HEAPF32[(($3607)>>2)];
9925       var $3609=($3595)+($3608);
9926       var $3610=$2;
9927       var $3611=(($3610+64)|0);
9928       var $3612=HEAP32[(($3611)>>2)];
9929       var $3613=$st;
9930       var $3614=(($3613+6)|0);
9931       var $3615=$3614;
9932       var $3616=HEAP16[(($3615)>>1)];
9933       var $3617=(($3616)&65535);
9934       var $3618=(($3612+($3617<<2))|0);
9935       var $3619=$3618;
9936       var $3620=$3619;
9937       var $3621=(($3620+4)|0);
9938       HEAPF32[(($3621)>>2)]=$3609;
9939       var $3622=$2;
9940       var $3623=(($3622+64)|0);
9941       var $3624=HEAP32[(($3623)>>2)];
9942       var $3625=$st;
9943       var $3626=(($3625+2)|0);
9944       var $3627=$3626;
9945       var $3628=HEAP16[(($3627)>>1)];
9946       var $3629=(($3628)&65535);
9947       var $3630=(($3624+($3629<<2))|0);
9948       var $3631=$3630;
9949       var $3632=$3631;
9950       var $3633=(($3632+8)|0);
9951       var $3634=HEAPF32[(($3633)>>2)];
9952       var $3635=$2;
9953       var $3636=(($3635+64)|0);
9954       var $3637=HEAP32[(($3636)>>2)];
9955       var $3638=$st;
9956       var $3639=(($3638+4)|0);
9957       var $3640=$3639;
9958       var $3641=HEAP16[(($3640)>>1)];
9959       var $3642=(($3641)&65535);
9960       var $3643=(($3637+($3642<<2))|0);
9961       var $3644=$3643;
9962       var $3645=$3644;
9963       var $3646=(($3645+8)|0);
9964       var $3647=HEAPF32[(($3646)>>2)];
9965       var $3648=($3634)+($3647);
9966       var $3649=$2;
9967       var $3650=(($3649+64)|0);
9968       var $3651=HEAP32[(($3650)>>2)];
9969       var $3652=$st;
9970       var $3653=(($3652+6)|0);
9971       var $3654=$3653;
9972       var $3655=HEAP16[(($3654)>>1)];
9973       var $3656=(($3655)&65535);
9974       var $3657=(($3651+($3656<<2))|0);
9975       var $3658=$3657;
9976       var $3659=$3658;
9977       var $3660=(($3659+8)|0);
9978       HEAPF32[(($3660)>>2)]=$3648;
9979       __label__ = 245; break;
9980     case 141:
9981       var $3662=$2;
9982       var $3663=(($3662+64)|0);
9983       var $3664=HEAP32[(($3663)>>2)];
9984       var $3665=$st;
9985       var $3666=(($3665+2)|0);
9986       var $3667=$3666;
9987       var $3668=HEAP16[(($3667)>>1)];
9988       var $3669=(($3668)&65535);
9989       var $3670=(($3664+($3669<<2))|0);
9990       var $3671=$3670;
9991       var $3672=$3671;
9992       var $3673=HEAPF32[(($3672)>>2)];
9993       var $3674=$2;
9994       var $3675=(($3674+64)|0);
9995       var $3676=HEAP32[(($3675)>>2)];
9996       var $3677=$st;
9997       var $3678=(($3677+4)|0);
9998       var $3679=$3678;
9999       var $3680=HEAP16[(($3679)>>1)];
10000       var $3681=(($3680)&65535);
10001       var $3682=(($3676+($3681<<2))|0);
10002       var $3683=$3682;
10003       var $3684=$3683;
10004       var $3685=HEAPF32[(($3684)>>2)];
10005       var $3686=($3673)-($3685);
10006       var $3687=$2;
10007       var $3688=(($3687+64)|0);
10008       var $3689=HEAP32[(($3688)>>2)];
10009       var $3690=$st;
10010       var $3691=(($3690+6)|0);
10011       var $3692=$3691;
10012       var $3693=HEAP16[(($3692)>>1)];
10013       var $3694=(($3693)&65535);
10014       var $3695=(($3689+($3694<<2))|0);
10015       var $3696=$3695;
10016       var $3697=$3696;
10017       HEAPF32[(($3697)>>2)]=$3686;
10018       __label__ = 245; break;
10019     case 142:
10020       var $3699=$2;
10021       var $3700=(($3699+64)|0);
10022       var $3701=HEAP32[(($3700)>>2)];
10023       var $3702=$st;
10024       var $3703=(($3702+2)|0);
10025       var $3704=$3703;
10026       var $3705=HEAP16[(($3704)>>1)];
10027       var $3706=(($3705)&65535);
10028       var $3707=(($3701+($3706<<2))|0);
10029       var $3708=$3707;
10030       var $3709=$3708;
10031       var $3710=(($3709)|0);
10032       var $3711=HEAPF32[(($3710)>>2)];
10033       var $3712=$2;
10034       var $3713=(($3712+64)|0);
10035       var $3714=HEAP32[(($3713)>>2)];
10036       var $3715=$st;
10037       var $3716=(($3715+4)|0);
10038       var $3717=$3716;
10039       var $3718=HEAP16[(($3717)>>1)];
10040       var $3719=(($3718)&65535);
10041       var $3720=(($3714+($3719<<2))|0);
10042       var $3721=$3720;
10043       var $3722=$3721;
10044       var $3723=(($3722)|0);
10045       var $3724=HEAPF32[(($3723)>>2)];
10046       var $3725=($3711)-($3724);
10047       var $3726=$2;
10048       var $3727=(($3726+64)|0);
10049       var $3728=HEAP32[(($3727)>>2)];
10050       var $3729=$st;
10051       var $3730=(($3729+6)|0);
10052       var $3731=$3730;
10053       var $3732=HEAP16[(($3731)>>1)];
10054       var $3733=(($3732)&65535);
10055       var $3734=(($3728+($3733<<2))|0);
10056       var $3735=$3734;
10057       var $3736=$3735;
10058       var $3737=(($3736)|0);
10059       HEAPF32[(($3737)>>2)]=$3725;
10060       var $3738=$2;
10061       var $3739=(($3738+64)|0);
10062       var $3740=HEAP32[(($3739)>>2)];
10063       var $3741=$st;
10064       var $3742=(($3741+2)|0);
10065       var $3743=$3742;
10066       var $3744=HEAP16[(($3743)>>1)];
10067       var $3745=(($3744)&65535);
10068       var $3746=(($3740+($3745<<2))|0);
10069       var $3747=$3746;
10070       var $3748=$3747;
10071       var $3749=(($3748+4)|0);
10072       var $3750=HEAPF32[(($3749)>>2)];
10073       var $3751=$2;
10074       var $3752=(($3751+64)|0);
10075       var $3753=HEAP32[(($3752)>>2)];
10076       var $3754=$st;
10077       var $3755=(($3754+4)|0);
10078       var $3756=$3755;
10079       var $3757=HEAP16[(($3756)>>1)];
10080       var $3758=(($3757)&65535);
10081       var $3759=(($3753+($3758<<2))|0);
10082       var $3760=$3759;
10083       var $3761=$3760;
10084       var $3762=(($3761+4)|0);
10085       var $3763=HEAPF32[(($3762)>>2)];
10086       var $3764=($3750)-($3763);
10087       var $3765=$2;
10088       var $3766=(($3765+64)|0);
10089       var $3767=HEAP32[(($3766)>>2)];
10090       var $3768=$st;
10091       var $3769=(($3768+6)|0);
10092       var $3770=$3769;
10093       var $3771=HEAP16[(($3770)>>1)];
10094       var $3772=(($3771)&65535);
10095       var $3773=(($3767+($3772<<2))|0);
10096       var $3774=$3773;
10097       var $3775=$3774;
10098       var $3776=(($3775+4)|0);
10099       HEAPF32[(($3776)>>2)]=$3764;
10100       var $3777=$2;
10101       var $3778=(($3777+64)|0);
10102       var $3779=HEAP32[(($3778)>>2)];
10103       var $3780=$st;
10104       var $3781=(($3780+2)|0);
10105       var $3782=$3781;
10106       var $3783=HEAP16[(($3782)>>1)];
10107       var $3784=(($3783)&65535);
10108       var $3785=(($3779+($3784<<2))|0);
10109       var $3786=$3785;
10110       var $3787=$3786;
10111       var $3788=(($3787+8)|0);
10112       var $3789=HEAPF32[(($3788)>>2)];
10113       var $3790=$2;
10114       var $3791=(($3790+64)|0);
10115       var $3792=HEAP32[(($3791)>>2)];
10116       var $3793=$st;
10117       var $3794=(($3793+4)|0);
10118       var $3795=$3794;
10119       var $3796=HEAP16[(($3795)>>1)];
10120       var $3797=(($3796)&65535);
10121       var $3798=(($3792+($3797<<2))|0);
10122       var $3799=$3798;
10123       var $3800=$3799;
10124       var $3801=(($3800+8)|0);
10125       var $3802=HEAPF32[(($3801)>>2)];
10126       var $3803=($3789)-($3802);
10127       var $3804=$2;
10128       var $3805=(($3804+64)|0);
10129       var $3806=HEAP32[(($3805)>>2)];
10130       var $3807=$st;
10131       var $3808=(($3807+6)|0);
10132       var $3809=$3808;
10133       var $3810=HEAP16[(($3809)>>1)];
10134       var $3811=(($3810)&65535);
10135       var $3812=(($3806+($3811<<2))|0);
10136       var $3813=$3812;
10137       var $3814=$3813;
10138       var $3815=(($3814+8)|0);
10139       HEAPF32[(($3815)>>2)]=$3803;
10140       __label__ = 245; break;
10141     case 143:
10142       var $3817=$2;
10143       var $3818=(($3817+64)|0);
10144       var $3819=HEAP32[(($3818)>>2)];
10145       var $3820=$st;
10146       var $3821=(($3820+2)|0);
10147       var $3822=$3821;
10148       var $3823=HEAP16[(($3822)>>1)];
10149       var $3824=(($3823)&65535);
10150       var $3825=(($3819+($3824<<2))|0);
10151       var $3826=$3825;
10152       var $3827=$3826;
10153       var $3828=HEAPF32[(($3827)>>2)];
10154       var $3829=$2;
10155       var $3830=(($3829+64)|0);
10156       var $3831=HEAP32[(($3830)>>2)];
10157       var $3832=$st;
10158       var $3833=(($3832+4)|0);
10159       var $3834=$3833;
10160       var $3835=HEAP16[(($3834)>>1)];
10161       var $3836=(($3835)&65535);
10162       var $3837=(($3831+($3836<<2))|0);
10163       var $3838=$3837;
10164       var $3839=$3838;
10165       var $3840=HEAPF32[(($3839)>>2)];
10166       var $3841=$3828 == $3840;
10167       var $3842=(($3841)&1);
10168       var $3843=(($3842)|0);
10169       var $3844=$2;
10170       var $3845=(($3844+64)|0);
10171       var $3846=HEAP32[(($3845)>>2)];
10172       var $3847=$st;
10173       var $3848=(($3847+6)|0);
10174       var $3849=$3848;
10175       var $3850=HEAP16[(($3849)>>1)];
10176       var $3851=(($3850)&65535);
10177       var $3852=(($3846+($3851<<2))|0);
10178       var $3853=$3852;
10179       var $3854=$3853;
10180       HEAPF32[(($3854)>>2)]=$3843;
10181       __label__ = 245; break;
10182     case 144:
10183       var $3856=$2;
10184       var $3857=(($3856+64)|0);
10185       var $3858=HEAP32[(($3857)>>2)];
10186       var $3859=$st;
10187       var $3860=(($3859+2)|0);
10188       var $3861=$3860;
10189       var $3862=HEAP16[(($3861)>>1)];
10190       var $3863=(($3862)&65535);
10191       var $3864=(($3858+($3863<<2))|0);
10192       var $3865=$3864;
10193       var $3866=$3865;
10194       var $3867=(($3866)|0);
10195       var $3868=HEAPF32[(($3867)>>2)];
10196       var $3869=$2;
10197       var $3870=(($3869+64)|0);
10198       var $3871=HEAP32[(($3870)>>2)];
10199       var $3872=$st;
10200       var $3873=(($3872+4)|0);
10201       var $3874=$3873;
10202       var $3875=HEAP16[(($3874)>>1)];
10203       var $3876=(($3875)&65535);
10204       var $3877=(($3871+($3876<<2))|0);
10205       var $3878=$3877;
10206       var $3879=$3878;
10207       var $3880=(($3879)|0);
10208       var $3881=HEAPF32[(($3880)>>2)];
10209       var $3882=$3868 == $3881;
10210       if ($3882) { __label__ = 145; break; } else { var $3940 = 0;__label__ = 147; break; }
10211     case 145:
10212       var $3884=$2;
10213       var $3885=(($3884+64)|0);
10214       var $3886=HEAP32[(($3885)>>2)];
10215       var $3887=$st;
10216       var $3888=(($3887+2)|0);
10217       var $3889=$3888;
10218       var $3890=HEAP16[(($3889)>>1)];
10219       var $3891=(($3890)&65535);
10220       var $3892=(($3886+($3891<<2))|0);
10221       var $3893=$3892;
10222       var $3894=$3893;
10223       var $3895=(($3894+4)|0);
10224       var $3896=HEAPF32[(($3895)>>2)];
10225       var $3897=$2;
10226       var $3898=(($3897+64)|0);
10227       var $3899=HEAP32[(($3898)>>2)];
10228       var $3900=$st;
10229       var $3901=(($3900+4)|0);
10230       var $3902=$3901;
10231       var $3903=HEAP16[(($3902)>>1)];
10232       var $3904=(($3903)&65535);
10233       var $3905=(($3899+($3904<<2))|0);
10234       var $3906=$3905;
10235       var $3907=$3906;
10236       var $3908=(($3907+4)|0);
10237       var $3909=HEAPF32[(($3908)>>2)];
10238       var $3910=$3896 == $3909;
10239       if ($3910) { __label__ = 146; break; } else { var $3940 = 0;__label__ = 147; break; }
10240     case 146:
10241       var $3912=$2;
10242       var $3913=(($3912+64)|0);
10243       var $3914=HEAP32[(($3913)>>2)];
10244       var $3915=$st;
10245       var $3916=(($3915+2)|0);
10246       var $3917=$3916;
10247       var $3918=HEAP16[(($3917)>>1)];
10248       var $3919=(($3918)&65535);
10249       var $3920=(($3914+($3919<<2))|0);
10250       var $3921=$3920;
10251       var $3922=$3921;
10252       var $3923=(($3922+8)|0);
10253       var $3924=HEAPF32[(($3923)>>2)];
10254       var $3925=$2;
10255       var $3926=(($3925+64)|0);
10256       var $3927=HEAP32[(($3926)>>2)];
10257       var $3928=$st;
10258       var $3929=(($3928+4)|0);
10259       var $3930=$3929;
10260       var $3931=HEAP16[(($3930)>>1)];
10261       var $3932=(($3931)&65535);
10262       var $3933=(($3927+($3932<<2))|0);
10263       var $3934=$3933;
10264       var $3935=$3934;
10265       var $3936=(($3935+8)|0);
10266       var $3937=HEAPF32[(($3936)>>2)];
10267       var $3938=$3924 == $3937;
10268       var $3940 = $3938;__label__ = 147; break;
10269     case 147:
10270       var $3940;
10271       var $3941=(($3940)&1);
10272       var $3942=(($3941)|0);
10273       var $3943=$2;
10274       var $3944=(($3943+64)|0);
10275       var $3945=HEAP32[(($3944)>>2)];
10276       var $3946=$st;
10277       var $3947=(($3946+6)|0);
10278       var $3948=$3947;
10279       var $3949=HEAP16[(($3948)>>1)];
10280       var $3950=(($3949)&65535);
10281       var $3951=(($3945+($3950<<2))|0);
10282       var $3952=$3951;
10283       var $3953=$3952;
10284       HEAPF32[(($3953)>>2)]=$3942;
10285       __label__ = 245; break;
10286     case 148:
10287       var $3955=$2;
10288       var $3956=$2;
10289       var $3957=(($3956+64)|0);
10290       var $3958=HEAP32[(($3957)>>2)];
10291       var $3959=$st;
10292       var $3960=(($3959+2)|0);
10293       var $3961=$3960;
10294       var $3962=HEAP16[(($3961)>>1)];
10295       var $3963=(($3962)&65535);
10296       var $3964=(($3958+($3963<<2))|0);
10297       var $3965=$3964;
10298       var $3966=$3965;
10299       var $3967=HEAP32[(($3966)>>2)];
10300       var $3968=_prog_getstring($3955, $3967);
10301       var $3969=$2;
10302       var $3970=$2;
10303       var $3971=(($3970+64)|0);
10304       var $3972=HEAP32[(($3971)>>2)];
10305       var $3973=$st;
10306       var $3974=(($3973+4)|0);
10307       var $3975=$3974;
10308       var $3976=HEAP16[(($3975)>>1)];
10309       var $3977=(($3976)&65535);
10310       var $3978=(($3972+($3977<<2))|0);
10311       var $3979=$3978;
10312       var $3980=$3979;
10313       var $3981=HEAP32[(($3980)>>2)];
10314       var $3982=_prog_getstring($3969, $3981);
10315       var $3983=_strcmp($3968, $3982);
10316       var $3984=(($3983)|0)!=0;
10317       var $3985=$3984 ^ 1;
10318       var $3986=(($3985)&1);
10319       var $3987=(($3986)|0);
10320       var $3988=$2;
10321       var $3989=(($3988+64)|0);
10322       var $3990=HEAP32[(($3989)>>2)];
10323       var $3991=$st;
10324       var $3992=(($3991+6)|0);
10325       var $3993=$3992;
10326       var $3994=HEAP16[(($3993)>>1)];
10327       var $3995=(($3994)&65535);
10328       var $3996=(($3990+($3995<<2))|0);
10329       var $3997=$3996;
10330       var $3998=$3997;
10331       HEAPF32[(($3998)>>2)]=$3987;
10332       __label__ = 245; break;
10333     case 149:
10334       var $4000=$2;
10335       var $4001=(($4000+64)|0);
10336       var $4002=HEAP32[(($4001)>>2)];
10337       var $4003=$st;
10338       var $4004=(($4003+2)|0);
10339       var $4005=$4004;
10340       var $4006=HEAP16[(($4005)>>1)];
10341       var $4007=(($4006)&65535);
10342       var $4008=(($4002+($4007<<2))|0);
10343       var $4009=$4008;
10344       var $4010=$4009;
10345       var $4011=HEAP32[(($4010)>>2)];
10346       var $4012=$2;
10347       var $4013=(($4012+64)|0);
10348       var $4014=HEAP32[(($4013)>>2)];
10349       var $4015=$st;
10350       var $4016=(($4015+4)|0);
10351       var $4017=$4016;
10352       var $4018=HEAP16[(($4017)>>1)];
10353       var $4019=(($4018)&65535);
10354       var $4020=(($4014+($4019<<2))|0);
10355       var $4021=$4020;
10356       var $4022=$4021;
10357       var $4023=HEAP32[(($4022)>>2)];
10358       var $4024=(($4011)|0)==(($4023)|0);
10359       var $4025=(($4024)&1);
10360       var $4026=(($4025)|0);
10361       var $4027=$2;
10362       var $4028=(($4027+64)|0);
10363       var $4029=HEAP32[(($4028)>>2)];
10364       var $4030=$st;
10365       var $4031=(($4030+6)|0);
10366       var $4032=$4031;
10367       var $4033=HEAP16[(($4032)>>1)];
10368       var $4034=(($4033)&65535);
10369       var $4035=(($4029+($4034<<2))|0);
10370       var $4036=$4035;
10371       var $4037=$4036;
10372       HEAPF32[(($4037)>>2)]=$4026;
10373       __label__ = 245; break;
10374     case 150:
10375       var $4039=$2;
10376       var $4040=(($4039+64)|0);
10377       var $4041=HEAP32[(($4040)>>2)];
10378       var $4042=$st;
10379       var $4043=(($4042+2)|0);
10380       var $4044=$4043;
10381       var $4045=HEAP16[(($4044)>>1)];
10382       var $4046=(($4045)&65535);
10383       var $4047=(($4041+($4046<<2))|0);
10384       var $4048=$4047;
10385       var $4049=$4048;
10386       var $4050=HEAP32[(($4049)>>2)];
10387       var $4051=$2;
10388       var $4052=(($4051+64)|0);
10389       var $4053=HEAP32[(($4052)>>2)];
10390       var $4054=$st;
10391       var $4055=(($4054+4)|0);
10392       var $4056=$4055;
10393       var $4057=HEAP16[(($4056)>>1)];
10394       var $4058=(($4057)&65535);
10395       var $4059=(($4053+($4058<<2))|0);
10396       var $4060=$4059;
10397       var $4061=$4060;
10398       var $4062=HEAP32[(($4061)>>2)];
10399       var $4063=(($4050)|0)==(($4062)|0);
10400       var $4064=(($4063)&1);
10401       var $4065=(($4064)|0);
10402       var $4066=$2;
10403       var $4067=(($4066+64)|0);
10404       var $4068=HEAP32[(($4067)>>2)];
10405       var $4069=$st;
10406       var $4070=(($4069+6)|0);
10407       var $4071=$4070;
10408       var $4072=HEAP16[(($4071)>>1)];
10409       var $4073=(($4072)&65535);
10410       var $4074=(($4068+($4073<<2))|0);
10411       var $4075=$4074;
10412       var $4076=$4075;
10413       HEAPF32[(($4076)>>2)]=$4065;
10414       __label__ = 245; break;
10415     case 151:
10416       var $4078=$2;
10417       var $4079=(($4078+64)|0);
10418       var $4080=HEAP32[(($4079)>>2)];
10419       var $4081=$st;
10420       var $4082=(($4081+2)|0);
10421       var $4083=$4082;
10422       var $4084=HEAP16[(($4083)>>1)];
10423       var $4085=(($4084)&65535);
10424       var $4086=(($4080+($4085<<2))|0);
10425       var $4087=$4086;
10426       var $4088=$4087;
10427       var $4089=HEAPF32[(($4088)>>2)];
10428       var $4090=$2;
10429       var $4091=(($4090+64)|0);
10430       var $4092=HEAP32[(($4091)>>2)];
10431       var $4093=$st;
10432       var $4094=(($4093+4)|0);
10433       var $4095=$4094;
10434       var $4096=HEAP16[(($4095)>>1)];
10435       var $4097=(($4096)&65535);
10436       var $4098=(($4092+($4097<<2))|0);
10437       var $4099=$4098;
10438       var $4100=$4099;
10439       var $4101=HEAPF32[(($4100)>>2)];
10440       var $4102=$4089 != $4101;
10441       var $4103=(($4102)&1);
10442       var $4104=(($4103)|0);
10443       var $4105=$2;
10444       var $4106=(($4105+64)|0);
10445       var $4107=HEAP32[(($4106)>>2)];
10446       var $4108=$st;
10447       var $4109=(($4108+6)|0);
10448       var $4110=$4109;
10449       var $4111=HEAP16[(($4110)>>1)];
10450       var $4112=(($4111)&65535);
10451       var $4113=(($4107+($4112<<2))|0);
10452       var $4114=$4113;
10453       var $4115=$4114;
10454       HEAPF32[(($4115)>>2)]=$4104;
10455       __label__ = 245; break;
10456     case 152:
10457       var $4117=$2;
10458       var $4118=(($4117+64)|0);
10459       var $4119=HEAP32[(($4118)>>2)];
10460       var $4120=$st;
10461       var $4121=(($4120+2)|0);
10462       var $4122=$4121;
10463       var $4123=HEAP16[(($4122)>>1)];
10464       var $4124=(($4123)&65535);
10465       var $4125=(($4119+($4124<<2))|0);
10466       var $4126=$4125;
10467       var $4127=$4126;
10468       var $4128=(($4127)|0);
10469       var $4129=HEAPF32[(($4128)>>2)];
10470       var $4130=$2;
10471       var $4131=(($4130+64)|0);
10472       var $4132=HEAP32[(($4131)>>2)];
10473       var $4133=$st;
10474       var $4134=(($4133+4)|0);
10475       var $4135=$4134;
10476       var $4136=HEAP16[(($4135)>>1)];
10477       var $4137=(($4136)&65535);
10478       var $4138=(($4132+($4137<<2))|0);
10479       var $4139=$4138;
10480       var $4140=$4139;
10481       var $4141=(($4140)|0);
10482       var $4142=HEAPF32[(($4141)>>2)];
10483       var $4143=$4129 != $4142;
10484       if ($4143) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 153; break; }
10485     case 153:
10486       var $4145=$2;
10487       var $4146=(($4145+64)|0);
10488       var $4147=HEAP32[(($4146)>>2)];
10489       var $4148=$st;
10490       var $4149=(($4148+2)|0);
10491       var $4150=$4149;
10492       var $4151=HEAP16[(($4150)>>1)];
10493       var $4152=(($4151)&65535);
10494       var $4153=(($4147+($4152<<2))|0);
10495       var $4154=$4153;
10496       var $4155=$4154;
10497       var $4156=(($4155+4)|0);
10498       var $4157=HEAPF32[(($4156)>>2)];
10499       var $4158=$2;
10500       var $4159=(($4158+64)|0);
10501       var $4160=HEAP32[(($4159)>>2)];
10502       var $4161=$st;
10503       var $4162=(($4161+4)|0);
10504       var $4163=$4162;
10505       var $4164=HEAP16[(($4163)>>1)];
10506       var $4165=(($4164)&65535);
10507       var $4166=(($4160+($4165<<2))|0);
10508       var $4167=$4166;
10509       var $4168=$4167;
10510       var $4169=(($4168+4)|0);
10511       var $4170=HEAPF32[(($4169)>>2)];
10512       var $4171=$4157 != $4170;
10513       if ($4171) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 154; break; }
10514     case 154:
10515       var $4173=$2;
10516       var $4174=(($4173+64)|0);
10517       var $4175=HEAP32[(($4174)>>2)];
10518       var $4176=$st;
10519       var $4177=(($4176+2)|0);
10520       var $4178=$4177;
10521       var $4179=HEAP16[(($4178)>>1)];
10522       var $4180=(($4179)&65535);
10523       var $4181=(($4175+($4180<<2))|0);
10524       var $4182=$4181;
10525       var $4183=$4182;
10526       var $4184=(($4183+8)|0);
10527       var $4185=HEAPF32[(($4184)>>2)];
10528       var $4186=$2;
10529       var $4187=(($4186+64)|0);
10530       var $4188=HEAP32[(($4187)>>2)];
10531       var $4189=$st;
10532       var $4190=(($4189+4)|0);
10533       var $4191=$4190;
10534       var $4192=HEAP16[(($4191)>>1)];
10535       var $4193=(($4192)&65535);
10536       var $4194=(($4188+($4193<<2))|0);
10537       var $4195=$4194;
10538       var $4196=$4195;
10539       var $4197=(($4196+8)|0);
10540       var $4198=HEAPF32[(($4197)>>2)];
10541       var $4199=$4185 != $4198;
10542       var $4201 = $4199;__label__ = 155; break;
10543     case 155:
10544       var $4201;
10545       var $4202=(($4201)&1);
10546       var $4203=(($4202)|0);
10547       var $4204=$2;
10548       var $4205=(($4204+64)|0);
10549       var $4206=HEAP32[(($4205)>>2)];
10550       var $4207=$st;
10551       var $4208=(($4207+6)|0);
10552       var $4209=$4208;
10553       var $4210=HEAP16[(($4209)>>1)];
10554       var $4211=(($4210)&65535);
10555       var $4212=(($4206+($4211<<2))|0);
10556       var $4213=$4212;
10557       var $4214=$4213;
10558       HEAPF32[(($4214)>>2)]=$4203;
10559       __label__ = 245; break;
10560     case 156:
10561       var $4216=$2;
10562       var $4217=$2;
10563       var $4218=(($4217+64)|0);
10564       var $4219=HEAP32[(($4218)>>2)];
10565       var $4220=$st;
10566       var $4221=(($4220+2)|0);
10567       var $4222=$4221;
10568       var $4223=HEAP16[(($4222)>>1)];
10569       var $4224=(($4223)&65535);
10570       var $4225=(($4219+($4224<<2))|0);
10571       var $4226=$4225;
10572       var $4227=$4226;
10573       var $4228=HEAP32[(($4227)>>2)];
10574       var $4229=_prog_getstring($4216, $4228);
10575       var $4230=$2;
10576       var $4231=$2;
10577       var $4232=(($4231+64)|0);
10578       var $4233=HEAP32[(($4232)>>2)];
10579       var $4234=$st;
10580       var $4235=(($4234+4)|0);
10581       var $4236=$4235;
10582       var $4237=HEAP16[(($4236)>>1)];
10583       var $4238=(($4237)&65535);
10584       var $4239=(($4233+($4238<<2))|0);
10585       var $4240=$4239;
10586       var $4241=$4240;
10587       var $4242=HEAP32[(($4241)>>2)];
10588       var $4243=_prog_getstring($4230, $4242);
10589       var $4244=_strcmp($4229, $4243);
10590       var $4245=(($4244)|0)!=0;
10591       var $4246=$4245 ^ 1;
10592       var $4247=$4246 ^ 1;
10593       var $4248=(($4247)&1);
10594       var $4249=(($4248)|0);
10595       var $4250=$2;
10596       var $4251=(($4250+64)|0);
10597       var $4252=HEAP32[(($4251)>>2)];
10598       var $4253=$st;
10599       var $4254=(($4253+6)|0);
10600       var $4255=$4254;
10601       var $4256=HEAP16[(($4255)>>1)];
10602       var $4257=(($4256)&65535);
10603       var $4258=(($4252+($4257<<2))|0);
10604       var $4259=$4258;
10605       var $4260=$4259;
10606       HEAPF32[(($4260)>>2)]=$4249;
10607       __label__ = 245; break;
10608     case 157:
10609       var $4262=$2;
10610       var $4263=(($4262+64)|0);
10611       var $4264=HEAP32[(($4263)>>2)];
10612       var $4265=$st;
10613       var $4266=(($4265+2)|0);
10614       var $4267=$4266;
10615       var $4268=HEAP16[(($4267)>>1)];
10616       var $4269=(($4268)&65535);
10617       var $4270=(($4264+($4269<<2))|0);
10618       var $4271=$4270;
10619       var $4272=$4271;
10620       var $4273=HEAP32[(($4272)>>2)];
10621       var $4274=$2;
10622       var $4275=(($4274+64)|0);
10623       var $4276=HEAP32[(($4275)>>2)];
10624       var $4277=$st;
10625       var $4278=(($4277+4)|0);
10626       var $4279=$4278;
10627       var $4280=HEAP16[(($4279)>>1)];
10628       var $4281=(($4280)&65535);
10629       var $4282=(($4276+($4281<<2))|0);
10630       var $4283=$4282;
10631       var $4284=$4283;
10632       var $4285=HEAP32[(($4284)>>2)];
10633       var $4286=(($4273)|0)!=(($4285)|0);
10634       var $4287=(($4286)&1);
10635       var $4288=(($4287)|0);
10636       var $4289=$2;
10637       var $4290=(($4289+64)|0);
10638       var $4291=HEAP32[(($4290)>>2)];
10639       var $4292=$st;
10640       var $4293=(($4292+6)|0);
10641       var $4294=$4293;
10642       var $4295=HEAP16[(($4294)>>1)];
10643       var $4296=(($4295)&65535);
10644       var $4297=(($4291+($4296<<2))|0);
10645       var $4298=$4297;
10646       var $4299=$4298;
10647       HEAPF32[(($4299)>>2)]=$4288;
10648       __label__ = 245; break;
10649     case 158:
10650       var $4301=$2;
10651       var $4302=(($4301+64)|0);
10652       var $4303=HEAP32[(($4302)>>2)];
10653       var $4304=$st;
10654       var $4305=(($4304+2)|0);
10655       var $4306=$4305;
10656       var $4307=HEAP16[(($4306)>>1)];
10657       var $4308=(($4307)&65535);
10658       var $4309=(($4303+($4308<<2))|0);
10659       var $4310=$4309;
10660       var $4311=$4310;
10661       var $4312=HEAP32[(($4311)>>2)];
10662       var $4313=$2;
10663       var $4314=(($4313+64)|0);
10664       var $4315=HEAP32[(($4314)>>2)];
10665       var $4316=$st;
10666       var $4317=(($4316+4)|0);
10667       var $4318=$4317;
10668       var $4319=HEAP16[(($4318)>>1)];
10669       var $4320=(($4319)&65535);
10670       var $4321=(($4315+($4320<<2))|0);
10671       var $4322=$4321;
10672       var $4323=$4322;
10673       var $4324=HEAP32[(($4323)>>2)];
10674       var $4325=(($4312)|0)!=(($4324)|0);
10675       var $4326=(($4325)&1);
10676       var $4327=(($4326)|0);
10677       var $4328=$2;
10678       var $4329=(($4328+64)|0);
10679       var $4330=HEAP32[(($4329)>>2)];
10680       var $4331=$st;
10681       var $4332=(($4331+6)|0);
10682       var $4333=$4332;
10683       var $4334=HEAP16[(($4333)>>1)];
10684       var $4335=(($4334)&65535);
10685       var $4336=(($4330+($4335<<2))|0);
10686       var $4337=$4336;
10687       var $4338=$4337;
10688       HEAPF32[(($4338)>>2)]=$4327;
10689       __label__ = 245; break;
10690     case 159:
10691       var $4340=$2;
10692       var $4341=(($4340+64)|0);
10693       var $4342=HEAP32[(($4341)>>2)];
10694       var $4343=$st;
10695       var $4344=(($4343+2)|0);
10696       var $4345=$4344;
10697       var $4346=HEAP16[(($4345)>>1)];
10698       var $4347=(($4346)&65535);
10699       var $4348=(($4342+($4347<<2))|0);
10700       var $4349=$4348;
10701       var $4350=$4349;
10702       var $4351=HEAPF32[(($4350)>>2)];
10703       var $4352=$2;
10704       var $4353=(($4352+64)|0);
10705       var $4354=HEAP32[(($4353)>>2)];
10706       var $4355=$st;
10707       var $4356=(($4355+4)|0);
10708       var $4357=$4356;
10709       var $4358=HEAP16[(($4357)>>1)];
10710       var $4359=(($4358)&65535);
10711       var $4360=(($4354+($4359<<2))|0);
10712       var $4361=$4360;
10713       var $4362=$4361;
10714       var $4363=HEAPF32[(($4362)>>2)];
10715       var $4364=$4351 <= $4363;
10716       var $4365=(($4364)&1);
10717       var $4366=(($4365)|0);
10718       var $4367=$2;
10719       var $4368=(($4367+64)|0);
10720       var $4369=HEAP32[(($4368)>>2)];
10721       var $4370=$st;
10722       var $4371=(($4370+6)|0);
10723       var $4372=$4371;
10724       var $4373=HEAP16[(($4372)>>1)];
10725       var $4374=(($4373)&65535);
10726       var $4375=(($4369+($4374<<2))|0);
10727       var $4376=$4375;
10728       var $4377=$4376;
10729       HEAPF32[(($4377)>>2)]=$4366;
10730       __label__ = 245; break;
10731     case 160:
10732       var $4379=$2;
10733       var $4380=(($4379+64)|0);
10734       var $4381=HEAP32[(($4380)>>2)];
10735       var $4382=$st;
10736       var $4383=(($4382+2)|0);
10737       var $4384=$4383;
10738       var $4385=HEAP16[(($4384)>>1)];
10739       var $4386=(($4385)&65535);
10740       var $4387=(($4381+($4386<<2))|0);
10741       var $4388=$4387;
10742       var $4389=$4388;
10743       var $4390=HEAPF32[(($4389)>>2)];
10744       var $4391=$2;
10745       var $4392=(($4391+64)|0);
10746       var $4393=HEAP32[(($4392)>>2)];
10747       var $4394=$st;
10748       var $4395=(($4394+4)|0);
10749       var $4396=$4395;
10750       var $4397=HEAP16[(($4396)>>1)];
10751       var $4398=(($4397)&65535);
10752       var $4399=(($4393+($4398<<2))|0);
10753       var $4400=$4399;
10754       var $4401=$4400;
10755       var $4402=HEAPF32[(($4401)>>2)];
10756       var $4403=$4390 >= $4402;
10757       var $4404=(($4403)&1);
10758       var $4405=(($4404)|0);
10759       var $4406=$2;
10760       var $4407=(($4406+64)|0);
10761       var $4408=HEAP32[(($4407)>>2)];
10762       var $4409=$st;
10763       var $4410=(($4409+6)|0);
10764       var $4411=$4410;
10765       var $4412=HEAP16[(($4411)>>1)];
10766       var $4413=(($4412)&65535);
10767       var $4414=(($4408+($4413<<2))|0);
10768       var $4415=$4414;
10769       var $4416=$4415;
10770       HEAPF32[(($4416)>>2)]=$4405;
10771       __label__ = 245; break;
10772     case 161:
10773       var $4418=$2;
10774       var $4419=(($4418+64)|0);
10775       var $4420=HEAP32[(($4419)>>2)];
10776       var $4421=$st;
10777       var $4422=(($4421+2)|0);
10778       var $4423=$4422;
10779       var $4424=HEAP16[(($4423)>>1)];
10780       var $4425=(($4424)&65535);
10781       var $4426=(($4420+($4425<<2))|0);
10782       var $4427=$4426;
10783       var $4428=$4427;
10784       var $4429=HEAPF32[(($4428)>>2)];
10785       var $4430=$2;
10786       var $4431=(($4430+64)|0);
10787       var $4432=HEAP32[(($4431)>>2)];
10788       var $4433=$st;
10789       var $4434=(($4433+4)|0);
10790       var $4435=$4434;
10791       var $4436=HEAP16[(($4435)>>1)];
10792       var $4437=(($4436)&65535);
10793       var $4438=(($4432+($4437<<2))|0);
10794       var $4439=$4438;
10795       var $4440=$4439;
10796       var $4441=HEAPF32[(($4440)>>2)];
10797       var $4442=$4429 < $4441;
10798       var $4443=(($4442)&1);
10799       var $4444=(($4443)|0);
10800       var $4445=$2;
10801       var $4446=(($4445+64)|0);
10802       var $4447=HEAP32[(($4446)>>2)];
10803       var $4448=$st;
10804       var $4449=(($4448+6)|0);
10805       var $4450=$4449;
10806       var $4451=HEAP16[(($4450)>>1)];
10807       var $4452=(($4451)&65535);
10808       var $4453=(($4447+($4452<<2))|0);
10809       var $4454=$4453;
10810       var $4455=$4454;
10811       HEAPF32[(($4455)>>2)]=$4444;
10812       __label__ = 245; break;
10813     case 162:
10814       var $4457=$2;
10815       var $4458=(($4457+64)|0);
10816       var $4459=HEAP32[(($4458)>>2)];
10817       var $4460=$st;
10818       var $4461=(($4460+2)|0);
10819       var $4462=$4461;
10820       var $4463=HEAP16[(($4462)>>1)];
10821       var $4464=(($4463)&65535);
10822       var $4465=(($4459+($4464<<2))|0);
10823       var $4466=$4465;
10824       var $4467=$4466;
10825       var $4468=HEAPF32[(($4467)>>2)];
10826       var $4469=$2;
10827       var $4470=(($4469+64)|0);
10828       var $4471=HEAP32[(($4470)>>2)];
10829       var $4472=$st;
10830       var $4473=(($4472+4)|0);
10831       var $4474=$4473;
10832       var $4475=HEAP16[(($4474)>>1)];
10833       var $4476=(($4475)&65535);
10834       var $4477=(($4471+($4476<<2))|0);
10835       var $4478=$4477;
10836       var $4479=$4478;
10837       var $4480=HEAPF32[(($4479)>>2)];
10838       var $4481=$4468 > $4480;
10839       var $4482=(($4481)&1);
10840       var $4483=(($4482)|0);
10841       var $4484=$2;
10842       var $4485=(($4484+64)|0);
10843       var $4486=HEAP32[(($4485)>>2)];
10844       var $4487=$st;
10845       var $4488=(($4487+6)|0);
10846       var $4489=$4488;
10847       var $4490=HEAP16[(($4489)>>1)];
10848       var $4491=(($4490)&65535);
10849       var $4492=(($4486+($4491<<2))|0);
10850       var $4493=$4492;
10851       var $4494=$4493;
10852       HEAPF32[(($4494)>>2)]=$4483;
10853       __label__ = 245; break;
10854     case 163:
10855       var $4496=$2;
10856       var $4497=(($4496+64)|0);
10857       var $4498=HEAP32[(($4497)>>2)];
10858       var $4499=$st;
10859       var $4500=(($4499+2)|0);
10860       var $4501=$4500;
10861       var $4502=HEAP16[(($4501)>>1)];
10862       var $4503=(($4502)&65535);
10863       var $4504=(($4498+($4503<<2))|0);
10864       var $4505=$4504;
10865       var $4506=$4505;
10866       var $4507=HEAP32[(($4506)>>2)];
10867       var $4508=(($4507)|0) < 0;
10868       if ($4508) { __label__ = 165; break; } else { __label__ = 164; break; }
10869     case 164:
10870       var $4510=$2;
10871       var $4511=(($4510+64)|0);
10872       var $4512=HEAP32[(($4511)>>2)];
10873       var $4513=$st;
10874       var $4514=(($4513+2)|0);
10875       var $4515=$4514;
10876       var $4516=HEAP16[(($4515)>>1)];
10877       var $4517=(($4516)&65535);
10878       var $4518=(($4512+($4517<<2))|0);
10879       var $4519=$4518;
10880       var $4520=$4519;
10881       var $4521=HEAP32[(($4520)>>2)];
10882       var $4522=$2;
10883       var $4523=(($4522+140)|0);
10884       var $4524=HEAP32[(($4523)>>2)];
10885       var $4525=(($4521)|0) >= (($4524)|0);
10886       if ($4525) { __label__ = 165; break; } else { __label__ = 166; break; }
10887     case 165:
10888       var $4527=$2;
10889       var $4528=$2;
10890       var $4529=(($4528)|0);
10891       var $4530=HEAP32[(($4529)>>2)];
10892       _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));
10893       __label__ = 488; break;
10894     case 166:
10895       var $4532=$2;
10896       var $4533=(($4532+64)|0);
10897       var $4534=HEAP32[(($4533)>>2)];
10898       var $4535=$st;
10899       var $4536=(($4535+4)|0);
10900       var $4537=$4536;
10901       var $4538=HEAP16[(($4537)>>1)];
10902       var $4539=(($4538)&65535);
10903       var $4540=(($4534+($4539<<2))|0);
10904       var $4541=$4540;
10905       var $4542=$4541;
10906       var $4543=HEAP32[(($4542)>>2)];
10907       var $4544=$2;
10908       var $4545=(($4544+144)|0);
10909       var $4546=HEAP32[(($4545)>>2)];
10910       var $4547=(($4543)>>>0) >= (($4546)>>>0);
10911       if ($4547) { __label__ = 167; break; } else { __label__ = 168; break; }
10912     case 167:
10913       var $4549=$2;
10914       var $4550=$2;
10915       var $4551=(($4550)|0);
10916       var $4552=HEAP32[(($4551)>>2)];
10917       var $4553=$2;
10918       var $4554=(($4553+64)|0);
10919       var $4555=HEAP32[(($4554)>>2)];
10920       var $4556=$st;
10921       var $4557=(($4556+4)|0);
10922       var $4558=$4557;
10923       var $4559=HEAP16[(($4558)>>1)];
10924       var $4560=(($4559)&65535);
10925       var $4561=(($4555+($4560<<2))|0);
10926       var $4562=$4561;
10927       var $4563=$4562;
10928       var $4564=HEAP32[(($4563)>>2)];
10929       _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));
10930       __label__ = 488; break;
10931     case 168:
10932       var $4566=$2;
10933       var $4567=$2;
10934       var $4568=(($4567+64)|0);
10935       var $4569=HEAP32[(($4568)>>2)];
10936       var $4570=$st;
10937       var $4571=(($4570+2)|0);
10938       var $4572=$4571;
10939       var $4573=HEAP16[(($4572)>>1)];
10940       var $4574=(($4573)&65535);
10941       var $4575=(($4569+($4574<<2))|0);
10942       var $4576=$4575;
10943       var $4577=$4576;
10944       var $4578=HEAP32[(($4577)>>2)];
10945       var $4579=_prog_getedict($4566, $4578);
10946       $ed2=$4579;
10947       var $4580=$ed2;
10948       var $4581=$4580;
10949       var $4582=$2;
10950       var $4583=(($4582+64)|0);
10951       var $4584=HEAP32[(($4583)>>2)];
10952       var $4585=$st;
10953       var $4586=(($4585+4)|0);
10954       var $4587=$4586;
10955       var $4588=HEAP16[(($4587)>>1)];
10956       var $4589=(($4588)&65535);
10957       var $4590=(($4584+($4589<<2))|0);
10958       var $4591=$4590;
10959       var $4592=$4591;
10960       var $4593=HEAP32[(($4592)>>2)];
10961       var $4594=(($4581+($4593<<2))|0);
10962       var $4595=$4594;
10963       var $4596=$4595;
10964       var $4597=HEAP32[(($4596)>>2)];
10965       var $4598=$2;
10966       var $4599=(($4598+64)|0);
10967       var $4600=HEAP32[(($4599)>>2)];
10968       var $4601=$st;
10969       var $4602=(($4601+6)|0);
10970       var $4603=$4602;
10971       var $4604=HEAP16[(($4603)>>1)];
10972       var $4605=(($4604)&65535);
10973       var $4606=(($4600+($4605<<2))|0);
10974       var $4607=$4606;
10975       var $4608=$4607;
10976       HEAP32[(($4608)>>2)]=$4597;
10977       __label__ = 245; break;
10978     case 169:
10979       var $4610=$2;
10980       var $4611=(($4610+64)|0);
10981       var $4612=HEAP32[(($4611)>>2)];
10982       var $4613=$st;
10983       var $4614=(($4613+2)|0);
10984       var $4615=$4614;
10985       var $4616=HEAP16[(($4615)>>1)];
10986       var $4617=(($4616)&65535);
10987       var $4618=(($4612+($4617<<2))|0);
10988       var $4619=$4618;
10989       var $4620=$4619;
10990       var $4621=HEAP32[(($4620)>>2)];
10991       var $4622=(($4621)|0) < 0;
10992       if ($4622) { __label__ = 171; break; } else { __label__ = 170; break; }
10993     case 170:
10994       var $4624=$2;
10995       var $4625=(($4624+64)|0);
10996       var $4626=HEAP32[(($4625)>>2)];
10997       var $4627=$st;
10998       var $4628=(($4627+2)|0);
10999       var $4629=$4628;
11000       var $4630=HEAP16[(($4629)>>1)];
11001       var $4631=(($4630)&65535);
11002       var $4632=(($4626+($4631<<2))|0);
11003       var $4633=$4632;
11004       var $4634=$4633;
11005       var $4635=HEAP32[(($4634)>>2)];
11006       var $4636=$2;
11007       var $4637=(($4636+140)|0);
11008       var $4638=HEAP32[(($4637)>>2)];
11009       var $4639=(($4635)|0) >= (($4638)|0);
11010       if ($4639) { __label__ = 171; break; } else { __label__ = 172; break; }
11011     case 171:
11012       var $4641=$2;
11013       var $4642=$2;
11014       var $4643=(($4642)|0);
11015       var $4644=HEAP32[(($4643)>>2)];
11016       _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));
11017       __label__ = 488; break;
11018     case 172:
11019       var $4646=$2;
11020       var $4647=(($4646+64)|0);
11021       var $4648=HEAP32[(($4647)>>2)];
11022       var $4649=$st;
11023       var $4650=(($4649+4)|0);
11024       var $4651=$4650;
11025       var $4652=HEAP16[(($4651)>>1)];
11026       var $4653=(($4652)&65535);
11027       var $4654=(($4648+($4653<<2))|0);
11028       var $4655=$4654;
11029       var $4656=$4655;
11030       var $4657=HEAP32[(($4656)>>2)];
11031       var $4658=(($4657)|0) < 0;
11032       if ($4658) { __label__ = 174; break; } else { __label__ = 173; break; }
11033     case 173:
11034       var $4660=$2;
11035       var $4661=(($4660+64)|0);
11036       var $4662=HEAP32[(($4661)>>2)];
11037       var $4663=$st;
11038       var $4664=(($4663+4)|0);
11039       var $4665=$4664;
11040       var $4666=HEAP16[(($4665)>>1)];
11041       var $4667=(($4666)&65535);
11042       var $4668=(($4662+($4667<<2))|0);
11043       var $4669=$4668;
11044       var $4670=$4669;
11045       var $4671=HEAP32[(($4670)>>2)];
11046       var $4672=((($4671)+(3))|0);
11047       var $4673=$2;
11048       var $4674=(($4673+144)|0);
11049       var $4675=HEAP32[(($4674)>>2)];
11050       var $4676=(($4672)>>>0) > (($4675)>>>0);
11051       if ($4676) { __label__ = 174; break; } else { __label__ = 175; break; }
11052     case 174:
11053       var $4678=$2;
11054       var $4679=$2;
11055       var $4680=(($4679)|0);
11056       var $4681=HEAP32[(($4680)>>2)];
11057       var $4682=$2;
11058       var $4683=(($4682+64)|0);
11059       var $4684=HEAP32[(($4683)>>2)];
11060       var $4685=$st;
11061       var $4686=(($4685+4)|0);
11062       var $4687=$4686;
11063       var $4688=HEAP16[(($4687)>>1)];
11064       var $4689=(($4688)&65535);
11065       var $4690=(($4684+($4689<<2))|0);
11066       var $4691=$4690;
11067       var $4692=$4691;
11068       var $4693=HEAP32[(($4692)>>2)];
11069       var $4694=((($4693)+(2))|0);
11070       _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));
11071       __label__ = 488; break;
11072     case 175:
11073       var $4696=$2;
11074       var $4697=$2;
11075       var $4698=(($4697+64)|0);
11076       var $4699=HEAP32[(($4698)>>2)];
11077       var $4700=$st;
11078       var $4701=(($4700+2)|0);
11079       var $4702=$4701;
11080       var $4703=HEAP16[(($4702)>>1)];
11081       var $4704=(($4703)&65535);
11082       var $4705=(($4699+($4704<<2))|0);
11083       var $4706=$4705;
11084       var $4707=$4706;
11085       var $4708=HEAP32[(($4707)>>2)];
11086       var $4709=_prog_getedict($4696, $4708);
11087       $ed2=$4709;
11088       var $4710=$ed2;
11089       var $4711=$4710;
11090       var $4712=$2;
11091       var $4713=(($4712+64)|0);
11092       var $4714=HEAP32[(($4713)>>2)];
11093       var $4715=$st;
11094       var $4716=(($4715+4)|0);
11095       var $4717=$4716;
11096       var $4718=HEAP16[(($4717)>>1)];
11097       var $4719=(($4718)&65535);
11098       var $4720=(($4714+($4719<<2))|0);
11099       var $4721=$4720;
11100       var $4722=$4721;
11101       var $4723=HEAP32[(($4722)>>2)];
11102       var $4724=(($4711+($4723<<2))|0);
11103       var $4725=$4724;
11104       var $4726=$4725;
11105       var $4727=(($4726)|0);
11106       var $4728=HEAP32[(($4727)>>2)];
11107       var $4729=$2;
11108       var $4730=(($4729+64)|0);
11109       var $4731=HEAP32[(($4730)>>2)];
11110       var $4732=$st;
11111       var $4733=(($4732+6)|0);
11112       var $4734=$4733;
11113       var $4735=HEAP16[(($4734)>>1)];
11114       var $4736=(($4735)&65535);
11115       var $4737=(($4731+($4736<<2))|0);
11116       var $4738=$4737;
11117       var $4739=$4738;
11118       var $4740=(($4739)|0);
11119       HEAP32[(($4740)>>2)]=$4728;
11120       var $4741=$ed2;
11121       var $4742=$4741;
11122       var $4743=$2;
11123       var $4744=(($4743+64)|0);
11124       var $4745=HEAP32[(($4744)>>2)];
11125       var $4746=$st;
11126       var $4747=(($4746+4)|0);
11127       var $4748=$4747;
11128       var $4749=HEAP16[(($4748)>>1)];
11129       var $4750=(($4749)&65535);
11130       var $4751=(($4745+($4750<<2))|0);
11131       var $4752=$4751;
11132       var $4753=$4752;
11133       var $4754=HEAP32[(($4753)>>2)];
11134       var $4755=(($4742+($4754<<2))|0);
11135       var $4756=$4755;
11136       var $4757=$4756;
11137       var $4758=(($4757+4)|0);
11138       var $4759=HEAP32[(($4758)>>2)];
11139       var $4760=$2;
11140       var $4761=(($4760+64)|0);
11141       var $4762=HEAP32[(($4761)>>2)];
11142       var $4763=$st;
11143       var $4764=(($4763+6)|0);
11144       var $4765=$4764;
11145       var $4766=HEAP16[(($4765)>>1)];
11146       var $4767=(($4766)&65535);
11147       var $4768=(($4762+($4767<<2))|0);
11148       var $4769=$4768;
11149       var $4770=$4769;
11150       var $4771=(($4770+4)|0);
11151       HEAP32[(($4771)>>2)]=$4759;
11152       var $4772=$ed2;
11153       var $4773=$4772;
11154       var $4774=$2;
11155       var $4775=(($4774+64)|0);
11156       var $4776=HEAP32[(($4775)>>2)];
11157       var $4777=$st;
11158       var $4778=(($4777+4)|0);
11159       var $4779=$4778;
11160       var $4780=HEAP16[(($4779)>>1)];
11161       var $4781=(($4780)&65535);
11162       var $4782=(($4776+($4781<<2))|0);
11163       var $4783=$4782;
11164       var $4784=$4783;
11165       var $4785=HEAP32[(($4784)>>2)];
11166       var $4786=(($4773+($4785<<2))|0);
11167       var $4787=$4786;
11168       var $4788=$4787;
11169       var $4789=(($4788+8)|0);
11170       var $4790=HEAP32[(($4789)>>2)];
11171       var $4791=$2;
11172       var $4792=(($4791+64)|0);
11173       var $4793=HEAP32[(($4792)>>2)];
11174       var $4794=$st;
11175       var $4795=(($4794+6)|0);
11176       var $4796=$4795;
11177       var $4797=HEAP16[(($4796)>>1)];
11178       var $4798=(($4797)&65535);
11179       var $4799=(($4793+($4798<<2))|0);
11180       var $4800=$4799;
11181       var $4801=$4800;
11182       var $4802=(($4801+8)|0);
11183       HEAP32[(($4802)>>2)]=$4790;
11184       __label__ = 245; break;
11185     case 176:
11186       var $4804=$2;
11187       var $4805=(($4804+64)|0);
11188       var $4806=HEAP32[(($4805)>>2)];
11189       var $4807=$st;
11190       var $4808=(($4807+2)|0);
11191       var $4809=$4808;
11192       var $4810=HEAP16[(($4809)>>1)];
11193       var $4811=(($4810)&65535);
11194       var $4812=(($4806+($4811<<2))|0);
11195       var $4813=$4812;
11196       var $4814=$4813;
11197       var $4815=HEAP32[(($4814)>>2)];
11198       var $4816=(($4815)|0) < 0;
11199       if ($4816) { __label__ = 178; break; } else { __label__ = 177; break; }
11200     case 177:
11201       var $4818=$2;
11202       var $4819=(($4818+64)|0);
11203       var $4820=HEAP32[(($4819)>>2)];
11204       var $4821=$st;
11205       var $4822=(($4821+2)|0);
11206       var $4823=$4822;
11207       var $4824=HEAP16[(($4823)>>1)];
11208       var $4825=(($4824)&65535);
11209       var $4826=(($4820+($4825<<2))|0);
11210       var $4827=$4826;
11211       var $4828=$4827;
11212       var $4829=HEAP32[(($4828)>>2)];
11213       var $4830=$2;
11214       var $4831=(($4830+140)|0);
11215       var $4832=HEAP32[(($4831)>>2)];
11216       var $4833=(($4829)|0) >= (($4832)|0);
11217       if ($4833) { __label__ = 178; break; } else { __label__ = 179; break; }
11218     case 178:
11219       var $4835=$2;
11220       var $4836=$2;
11221       var $4837=(($4836)|0);
11222       var $4838=HEAP32[(($4837)>>2)];
11223       var $4839=$2;
11224       var $4840=(($4839+64)|0);
11225       var $4841=HEAP32[(($4840)>>2)];
11226       var $4842=$st;
11227       var $4843=(($4842+2)|0);
11228       var $4844=$4843;
11229       var $4845=HEAP16[(($4844)>>1)];
11230       var $4846=(($4845)&65535);
11231       var $4847=(($4841+($4846<<2))|0);
11232       var $4848=$4847;
11233       var $4849=$4848;
11234       var $4850=HEAP32[(($4849)>>2)];
11235       _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));
11236       __label__ = 488; break;
11237     case 179:
11238       var $4852=$2;
11239       var $4853=(($4852+64)|0);
11240       var $4854=HEAP32[(($4853)>>2)];
11241       var $4855=$st;
11242       var $4856=(($4855+4)|0);
11243       var $4857=$4856;
11244       var $4858=HEAP16[(($4857)>>1)];
11245       var $4859=(($4858)&65535);
11246       var $4860=(($4854+($4859<<2))|0);
11247       var $4861=$4860;
11248       var $4862=$4861;
11249       var $4863=HEAP32[(($4862)>>2)];
11250       var $4864=$2;
11251       var $4865=(($4864+144)|0);
11252       var $4866=HEAP32[(($4865)>>2)];
11253       var $4867=(($4863)>>>0) >= (($4866)>>>0);
11254       if ($4867) { __label__ = 180; break; } else { __label__ = 181; break; }
11255     case 180:
11256       var $4869=$2;
11257       var $4870=$2;
11258       var $4871=(($4870)|0);
11259       var $4872=HEAP32[(($4871)>>2)];
11260       var $4873=$2;
11261       var $4874=(($4873+64)|0);
11262       var $4875=HEAP32[(($4874)>>2)];
11263       var $4876=$st;
11264       var $4877=(($4876+4)|0);
11265       var $4878=$4877;
11266       var $4879=HEAP16[(($4878)>>1)];
11267       var $4880=(($4879)&65535);
11268       var $4881=(($4875+($4880<<2))|0);
11269       var $4882=$4881;
11270       var $4883=$4882;
11271       var $4884=HEAP32[(($4883)>>2)];
11272       _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));
11273       __label__ = 488; break;
11274     case 181:
11275       var $4886=$2;
11276       var $4887=$2;
11277       var $4888=(($4887+64)|0);
11278       var $4889=HEAP32[(($4888)>>2)];
11279       var $4890=$st;
11280       var $4891=(($4890+2)|0);
11281       var $4892=$4891;
11282       var $4893=HEAP16[(($4892)>>1)];
11283       var $4894=(($4893)&65535);
11284       var $4895=(($4889+($4894<<2))|0);
11285       var $4896=$4895;
11286       var $4897=$4896;
11287       var $4898=HEAP32[(($4897)>>2)];
11288       var $4899=_prog_getedict($4886, $4898);
11289       $ed2=$4899;
11290       var $4900=$ed2;
11291       var $4901=$4900;
11292       var $4902=$2;
11293       var $4903=(($4902+76)|0);
11294       var $4904=HEAP32[(($4903)>>2)];
11295       var $4905=$4901;
11296       var $4906=$4904;
11297       var $4907=((($4905)-($4906))|0);
11298       var $4908=((((($4907)|0))/(4))&-1);
11299       var $4909=$2;
11300       var $4910=(($4909+64)|0);
11301       var $4911=HEAP32[(($4910)>>2)];
11302       var $4912=$st;
11303       var $4913=(($4912+6)|0);
11304       var $4914=$4913;
11305       var $4915=HEAP16[(($4914)>>1)];
11306       var $4916=(($4915)&65535);
11307       var $4917=(($4911+($4916<<2))|0);
11308       var $4918=$4917;
11309       var $4919=$4918;
11310       HEAP32[(($4919)>>2)]=$4908;
11311       var $4920=$2;
11312       var $4921=(($4920+64)|0);
11313       var $4922=HEAP32[(($4921)>>2)];
11314       var $4923=$st;
11315       var $4924=(($4923+4)|0);
11316       var $4925=$4924;
11317       var $4926=HEAP16[(($4925)>>1)];
11318       var $4927=(($4926)&65535);
11319       var $4928=(($4922+($4927<<2))|0);
11320       var $4929=$4928;
11321       var $4930=$4929;
11322       var $4931=HEAP32[(($4930)>>2)];
11323       var $4932=$2;
11324       var $4933=(($4932+64)|0);
11325       var $4934=HEAP32[(($4933)>>2)];
11326       var $4935=$st;
11327       var $4936=(($4935+6)|0);
11328       var $4937=$4936;
11329       var $4938=HEAP16[(($4937)>>1)];
11330       var $4939=(($4938)&65535);
11331       var $4940=(($4934+($4939<<2))|0);
11332       var $4941=$4940;
11333       var $4942=$4941;
11334       var $4943=HEAP32[(($4942)>>2)];
11335       var $4944=((($4943)+($4931))|0);
11336       HEAP32[(($4942)>>2)]=$4944;
11337       __label__ = 245; break;
11338     case 182:
11339       var $4946=$2;
11340       var $4947=(($4946+64)|0);
11341       var $4948=HEAP32[(($4947)>>2)];
11342       var $4949=$st;
11343       var $4950=(($4949+2)|0);
11344       var $4951=$4950;
11345       var $4952=HEAP16[(($4951)>>1)];
11346       var $4953=(($4952)&65535);
11347       var $4954=(($4948+($4953<<2))|0);
11348       var $4955=$4954;
11349       var $4956=$4955;
11350       var $4957=HEAP32[(($4956)>>2)];
11351       var $4958=$2;
11352       var $4959=(($4958+64)|0);
11353       var $4960=HEAP32[(($4959)>>2)];
11354       var $4961=$st;
11355       var $4962=(($4961+4)|0);
11356       var $4963=$4962;
11357       var $4964=HEAP16[(($4963)>>1)];
11358       var $4965=(($4964)&65535);
11359       var $4966=(($4960+($4965<<2))|0);
11360       var $4967=$4966;
11361       var $4968=$4967;
11362       HEAP32[(($4968)>>2)]=$4957;
11363       __label__ = 245; break;
11364     case 183:
11365       var $4970=$2;
11366       var $4971=(($4970+64)|0);
11367       var $4972=HEAP32[(($4971)>>2)];
11368       var $4973=$st;
11369       var $4974=(($4973+2)|0);
11370       var $4975=$4974;
11371       var $4976=HEAP16[(($4975)>>1)];
11372       var $4977=(($4976)&65535);
11373       var $4978=(($4972+($4977<<2))|0);
11374       var $4979=$4978;
11375       var $4980=$4979;
11376       var $4981=(($4980)|0);
11377       var $4982=HEAP32[(($4981)>>2)];
11378       var $4983=$2;
11379       var $4984=(($4983+64)|0);
11380       var $4985=HEAP32[(($4984)>>2)];
11381       var $4986=$st;
11382       var $4987=(($4986+4)|0);
11383       var $4988=$4987;
11384       var $4989=HEAP16[(($4988)>>1)];
11385       var $4990=(($4989)&65535);
11386       var $4991=(($4985+($4990<<2))|0);
11387       var $4992=$4991;
11388       var $4993=$4992;
11389       var $4994=(($4993)|0);
11390       HEAP32[(($4994)>>2)]=$4982;
11391       var $4995=$2;
11392       var $4996=(($4995+64)|0);
11393       var $4997=HEAP32[(($4996)>>2)];
11394       var $4998=$st;
11395       var $4999=(($4998+2)|0);
11396       var $5000=$4999;
11397       var $5001=HEAP16[(($5000)>>1)];
11398       var $5002=(($5001)&65535);
11399       var $5003=(($4997+($5002<<2))|0);
11400       var $5004=$5003;
11401       var $5005=$5004;
11402       var $5006=(($5005+4)|0);
11403       var $5007=HEAP32[(($5006)>>2)];
11404       var $5008=$2;
11405       var $5009=(($5008+64)|0);
11406       var $5010=HEAP32[(($5009)>>2)];
11407       var $5011=$st;
11408       var $5012=(($5011+4)|0);
11409       var $5013=$5012;
11410       var $5014=HEAP16[(($5013)>>1)];
11411       var $5015=(($5014)&65535);
11412       var $5016=(($5010+($5015<<2))|0);
11413       var $5017=$5016;
11414       var $5018=$5017;
11415       var $5019=(($5018+4)|0);
11416       HEAP32[(($5019)>>2)]=$5007;
11417       var $5020=$2;
11418       var $5021=(($5020+64)|0);
11419       var $5022=HEAP32[(($5021)>>2)];
11420       var $5023=$st;
11421       var $5024=(($5023+2)|0);
11422       var $5025=$5024;
11423       var $5026=HEAP16[(($5025)>>1)];
11424       var $5027=(($5026)&65535);
11425       var $5028=(($5022+($5027<<2))|0);
11426       var $5029=$5028;
11427       var $5030=$5029;
11428       var $5031=(($5030+8)|0);
11429       var $5032=HEAP32[(($5031)>>2)];
11430       var $5033=$2;
11431       var $5034=(($5033+64)|0);
11432       var $5035=HEAP32[(($5034)>>2)];
11433       var $5036=$st;
11434       var $5037=(($5036+4)|0);
11435       var $5038=$5037;
11436       var $5039=HEAP16[(($5038)>>1)];
11437       var $5040=(($5039)&65535);
11438       var $5041=(($5035+($5040<<2))|0);
11439       var $5042=$5041;
11440       var $5043=$5042;
11441       var $5044=(($5043+8)|0);
11442       HEAP32[(($5044)>>2)]=$5032;
11443       __label__ = 245; break;
11444     case 184:
11445       var $5046=$2;
11446       var $5047=(($5046+64)|0);
11447       var $5048=HEAP32[(($5047)>>2)];
11448       var $5049=$st;
11449       var $5050=(($5049+4)|0);
11450       var $5051=$5050;
11451       var $5052=HEAP16[(($5051)>>1)];
11452       var $5053=(($5052)&65535);
11453       var $5054=(($5048+($5053<<2))|0);
11454       var $5055=$5054;
11455       var $5056=$5055;
11456       var $5057=HEAP32[(($5056)>>2)];
11457       var $5058=(($5057)|0) < 0;
11458       if ($5058) { __label__ = 186; break; } else { __label__ = 185; break; }
11459     case 185:
11460       var $5060=$2;
11461       var $5061=(($5060+64)|0);
11462       var $5062=HEAP32[(($5061)>>2)];
11463       var $5063=$st;
11464       var $5064=(($5063+4)|0);
11465       var $5065=$5064;
11466       var $5066=HEAP16[(($5065)>>1)];
11467       var $5067=(($5066)&65535);
11468       var $5068=(($5062+($5067<<2))|0);
11469       var $5069=$5068;
11470       var $5070=$5069;
11471       var $5071=HEAP32[(($5070)>>2)];
11472       var $5072=$2;
11473       var $5073=(($5072+80)|0);
11474       var $5074=HEAP32[(($5073)>>2)];
11475       var $5075=(($5071)>>>0) >= (($5074)>>>0);
11476       if ($5075) { __label__ = 186; break; } else { __label__ = 187; break; }
11477     case 186:
11478       var $5077=$2;
11479       var $5078=$2;
11480       var $5079=(($5078)|0);
11481       var $5080=HEAP32[(($5079)>>2)];
11482       var $5081=$2;
11483       var $5082=(($5081+64)|0);
11484       var $5083=HEAP32[(($5082)>>2)];
11485       var $5084=$st;
11486       var $5085=(($5084+4)|0);
11487       var $5086=$5085;
11488       var $5087=HEAP16[(($5086)>>1)];
11489       var $5088=(($5087)&65535);
11490       var $5089=(($5083+($5088<<2))|0);
11491       var $5090=$5089;
11492       var $5091=$5090;
11493       var $5092=HEAP32[(($5091)>>2)];
11494       _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));
11495       __label__ = 488; break;
11496     case 187:
11497       var $5094=$2;
11498       var $5095=(($5094+64)|0);
11499       var $5096=HEAP32[(($5095)>>2)];
11500       var $5097=$st;
11501       var $5098=(($5097+4)|0);
11502       var $5099=$5098;
11503       var $5100=HEAP16[(($5099)>>1)];
11504       var $5101=(($5100)&65535);
11505       var $5102=(($5096+($5101<<2))|0);
11506       var $5103=$5102;
11507       var $5104=$5103;
11508       var $5105=HEAP32[(($5104)>>2)];
11509       var $5106=$2;
11510       var $5107=(($5106+144)|0);
11511       var $5108=HEAP32[(($5107)>>2)];
11512       var $5109=(($5105)>>>0) < (($5108)>>>0);
11513       if ($5109) { __label__ = 188; break; } else { __label__ = 190; break; }
11514     case 188:
11515       var $5111=$2;
11516       var $5112=(($5111+148)|0);
11517       var $5113=HEAP8[($5112)];
11518       var $5114=(($5113) & 1);
11519       if ($5114) { __label__ = 190; break; } else { __label__ = 189; break; }
11520     case 189:
11521       var $5116=$2;
11522       var $5117=$2;
11523       var $5118=(($5117)|0);
11524       var $5119=HEAP32[(($5118)>>2)];
11525       var $5120=$2;
11526       var $5121=$2;
11527       var $5122=$2;
11528       var $5123=(($5122+64)|0);
11529       var $5124=HEAP32[(($5123)>>2)];
11530       var $5125=$st;
11531       var $5126=(($5125+4)|0);
11532       var $5127=$5126;
11533       var $5128=HEAP16[(($5127)>>1)];
11534       var $5129=(($5128)&65535);
11535       var $5130=(($5124+($5129<<2))|0);
11536       var $5131=$5130;
11537       var $5132=$5131;
11538       var $5133=HEAP32[(($5132)>>2)];
11539       var $5134=_prog_entfield($5121, $5133);
11540       var $5135=(($5134+4)|0);
11541       var $5136=HEAP32[(($5135)>>2)];
11542       var $5137=_prog_getstring($5120, $5136);
11543       var $5138=$2;
11544       var $5139=(($5138+64)|0);
11545       var $5140=HEAP32[(($5139)>>2)];
11546       var $5141=$st;
11547       var $5142=(($5141+4)|0);
11548       var $5143=$5142;
11549       var $5144=HEAP16[(($5143)>>1)];
11550       var $5145=(($5144)&65535);
11551       var $5146=(($5140+($5145<<2))|0);
11552       var $5147=$5146;
11553       var $5148=$5147;
11554       var $5149=HEAP32[(($5148)>>2)];
11555       _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));
11556       __label__ = 190; break;
11557     case 190:
11558       var $5151=$2;
11559       var $5152=(($5151+76)|0);
11560       var $5153=HEAP32[(($5152)>>2)];
11561       var $5154=$2;
11562       var $5155=(($5154+64)|0);
11563       var $5156=HEAP32[(($5155)>>2)];
11564       var $5157=$st;
11565       var $5158=(($5157+4)|0);
11566       var $5159=$5158;
11567       var $5160=HEAP16[(($5159)>>1)];
11568       var $5161=(($5160)&65535);
11569       var $5162=(($5156+($5161<<2))|0);
11570       var $5163=$5162;
11571       var $5164=$5163;
11572       var $5165=HEAP32[(($5164)>>2)];
11573       var $5166=(($5153+($5165<<2))|0);
11574       var $5167=$5166;
11575       $ptr3=$5167;
11576       var $5168=$2;
11577       var $5169=(($5168+64)|0);
11578       var $5170=HEAP32[(($5169)>>2)];
11579       var $5171=$st;
11580       var $5172=(($5171+2)|0);
11581       var $5173=$5172;
11582       var $5174=HEAP16[(($5173)>>1)];
11583       var $5175=(($5174)&65535);
11584       var $5176=(($5170+($5175<<2))|0);
11585       var $5177=$5176;
11586       var $5178=$5177;
11587       var $5179=HEAP32[(($5178)>>2)];
11588       var $5180=$ptr3;
11589       var $5181=$5180;
11590       HEAP32[(($5181)>>2)]=$5179;
11591       __label__ = 245; break;
11592     case 191:
11593       var $5183=$2;
11594       var $5184=(($5183+64)|0);
11595       var $5185=HEAP32[(($5184)>>2)];
11596       var $5186=$st;
11597       var $5187=(($5186+4)|0);
11598       var $5188=$5187;
11599       var $5189=HEAP16[(($5188)>>1)];
11600       var $5190=(($5189)&65535);
11601       var $5191=(($5185+($5190<<2))|0);
11602       var $5192=$5191;
11603       var $5193=$5192;
11604       var $5194=HEAP32[(($5193)>>2)];
11605       var $5195=(($5194)|0) < 0;
11606       if ($5195) { __label__ = 193; break; } else { __label__ = 192; break; }
11607     case 192:
11608       var $5197=$2;
11609       var $5198=(($5197+64)|0);
11610       var $5199=HEAP32[(($5198)>>2)];
11611       var $5200=$st;
11612       var $5201=(($5200+4)|0);
11613       var $5202=$5201;
11614       var $5203=HEAP16[(($5202)>>1)];
11615       var $5204=(($5203)&65535);
11616       var $5205=(($5199+($5204<<2))|0);
11617       var $5206=$5205;
11618       var $5207=$5206;
11619       var $5208=HEAP32[(($5207)>>2)];
11620       var $5209=((($5208)+(2))|0);
11621       var $5210=$2;
11622       var $5211=(($5210+80)|0);
11623       var $5212=HEAP32[(($5211)>>2)];
11624       var $5213=(($5209)>>>0) >= (($5212)>>>0);
11625       if ($5213) { __label__ = 193; break; } else { __label__ = 194; break; }
11626     case 193:
11627       var $5215=$2;
11628       var $5216=$2;
11629       var $5217=(($5216)|0);
11630       var $5218=HEAP32[(($5217)>>2)];
11631       var $5219=$2;
11632       var $5220=(($5219+64)|0);
11633       var $5221=HEAP32[(($5220)>>2)];
11634       var $5222=$st;
11635       var $5223=(($5222+4)|0);
11636       var $5224=$5223;
11637       var $5225=HEAP16[(($5224)>>1)];
11638       var $5226=(($5225)&65535);
11639       var $5227=(($5221+($5226<<2))|0);
11640       var $5228=$5227;
11641       var $5229=$5228;
11642       var $5230=HEAP32[(($5229)>>2)];
11643       _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));
11644       __label__ = 488; break;
11645     case 194:
11646       var $5232=$2;
11647       var $5233=(($5232+64)|0);
11648       var $5234=HEAP32[(($5233)>>2)];
11649       var $5235=$st;
11650       var $5236=(($5235+4)|0);
11651       var $5237=$5236;
11652       var $5238=HEAP16[(($5237)>>1)];
11653       var $5239=(($5238)&65535);
11654       var $5240=(($5234+($5239<<2))|0);
11655       var $5241=$5240;
11656       var $5242=$5241;
11657       var $5243=HEAP32[(($5242)>>2)];
11658       var $5244=$2;
11659       var $5245=(($5244+144)|0);
11660       var $5246=HEAP32[(($5245)>>2)];
11661       var $5247=(($5243)>>>0) < (($5246)>>>0);
11662       if ($5247) { __label__ = 195; break; } else { __label__ = 197; break; }
11663     case 195:
11664       var $5249=$2;
11665       var $5250=(($5249+148)|0);
11666       var $5251=HEAP8[($5250)];
11667       var $5252=(($5251) & 1);
11668       if ($5252) { __label__ = 197; break; } else { __label__ = 196; break; }
11669     case 196:
11670       var $5254=$2;
11671       var $5255=$2;
11672       var $5256=(($5255)|0);
11673       var $5257=HEAP32[(($5256)>>2)];
11674       var $5258=$2;
11675       var $5259=$2;
11676       var $5260=$2;
11677       var $5261=(($5260+64)|0);
11678       var $5262=HEAP32[(($5261)>>2)];
11679       var $5263=$st;
11680       var $5264=(($5263+4)|0);
11681       var $5265=$5264;
11682       var $5266=HEAP16[(($5265)>>1)];
11683       var $5267=(($5266)&65535);
11684       var $5268=(($5262+($5267<<2))|0);
11685       var $5269=$5268;
11686       var $5270=$5269;
11687       var $5271=HEAP32[(($5270)>>2)];
11688       var $5272=_prog_entfield($5259, $5271);
11689       var $5273=(($5272+4)|0);
11690       var $5274=HEAP32[(($5273)>>2)];
11691       var $5275=_prog_getstring($5258, $5274);
11692       var $5276=$2;
11693       var $5277=(($5276+64)|0);
11694       var $5278=HEAP32[(($5277)>>2)];
11695       var $5279=$st;
11696       var $5280=(($5279+4)|0);
11697       var $5281=$5280;
11698       var $5282=HEAP16[(($5281)>>1)];
11699       var $5283=(($5282)&65535);
11700       var $5284=(($5278+($5283<<2))|0);
11701       var $5285=$5284;
11702       var $5286=$5285;
11703       var $5287=HEAP32[(($5286)>>2)];
11704       _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));
11705       __label__ = 197; break;
11706     case 197:
11707       var $5289=$2;
11708       var $5290=(($5289+76)|0);
11709       var $5291=HEAP32[(($5290)>>2)];
11710       var $5292=$2;
11711       var $5293=(($5292+64)|0);
11712       var $5294=HEAP32[(($5293)>>2)];
11713       var $5295=$st;
11714       var $5296=(($5295+4)|0);
11715       var $5297=$5296;
11716       var $5298=HEAP16[(($5297)>>1)];
11717       var $5299=(($5298)&65535);
11718       var $5300=(($5294+($5299<<2))|0);
11719       var $5301=$5300;
11720       var $5302=$5301;
11721       var $5303=HEAP32[(($5302)>>2)];
11722       var $5304=(($5291+($5303<<2))|0);
11723       var $5305=$5304;
11724       $ptr3=$5305;
11725       var $5306=$2;
11726       var $5307=(($5306+64)|0);
11727       var $5308=HEAP32[(($5307)>>2)];
11728       var $5309=$st;
11729       var $5310=(($5309+2)|0);
11730       var $5311=$5310;
11731       var $5312=HEAP16[(($5311)>>1)];
11732       var $5313=(($5312)&65535);
11733       var $5314=(($5308+($5313<<2))|0);
11734       var $5315=$5314;
11735       var $5316=$5315;
11736       var $5317=(($5316)|0);
11737       var $5318=HEAP32[(($5317)>>2)];
11738       var $5319=$ptr3;
11739       var $5320=$5319;
11740       var $5321=(($5320)|0);
11741       HEAP32[(($5321)>>2)]=$5318;
11742       var $5322=$2;
11743       var $5323=(($5322+64)|0);
11744       var $5324=HEAP32[(($5323)>>2)];
11745       var $5325=$st;
11746       var $5326=(($5325+2)|0);
11747       var $5327=$5326;
11748       var $5328=HEAP16[(($5327)>>1)];
11749       var $5329=(($5328)&65535);
11750       var $5330=(($5324+($5329<<2))|0);
11751       var $5331=$5330;
11752       var $5332=$5331;
11753       var $5333=(($5332+4)|0);
11754       var $5334=HEAP32[(($5333)>>2)];
11755       var $5335=$ptr3;
11756       var $5336=$5335;
11757       var $5337=(($5336+4)|0);
11758       HEAP32[(($5337)>>2)]=$5334;
11759       var $5338=$2;
11760       var $5339=(($5338+64)|0);
11761       var $5340=HEAP32[(($5339)>>2)];
11762       var $5341=$st;
11763       var $5342=(($5341+2)|0);
11764       var $5343=$5342;
11765       var $5344=HEAP16[(($5343)>>1)];
11766       var $5345=(($5344)&65535);
11767       var $5346=(($5340+($5345<<2))|0);
11768       var $5347=$5346;
11769       var $5348=$5347;
11770       var $5349=(($5348+8)|0);
11771       var $5350=HEAP32[(($5349)>>2)];
11772       var $5351=$ptr3;
11773       var $5352=$5351;
11774       var $5353=(($5352+8)|0);
11775       HEAP32[(($5353)>>2)]=$5350;
11776       __label__ = 245; break;
11777     case 198:
11778       var $5355=$2;
11779       var $5356=(($5355+64)|0);
11780       var $5357=HEAP32[(($5356)>>2)];
11781       var $5358=$st;
11782       var $5359=(($5358+2)|0);
11783       var $5360=$5359;
11784       var $5361=HEAP16[(($5360)>>1)];
11785       var $5362=(($5361)&65535);
11786       var $5363=(($5357+($5362<<2))|0);
11787       var $5364=$5363;
11788       var $5365=$5364;
11789       var $5366=HEAP32[(($5365)>>2)];
11790       var $5367=$5366 & 2147483647;
11791       var $5368=(($5367)|0)!=0;
11792       var $5369=$5368 ^ 1;
11793       var $5370=(($5369)&1);
11794       var $5371=(($5370)|0);
11795       var $5372=$2;
11796       var $5373=(($5372+64)|0);
11797       var $5374=HEAP32[(($5373)>>2)];
11798       var $5375=$st;
11799       var $5376=(($5375+6)|0);
11800       var $5377=$5376;
11801       var $5378=HEAP16[(($5377)>>1)];
11802       var $5379=(($5378)&65535);
11803       var $5380=(($5374+($5379<<2))|0);
11804       var $5381=$5380;
11805       var $5382=$5381;
11806       HEAPF32[(($5382)>>2)]=$5371;
11807       __label__ = 245; break;
11808     case 199:
11809       var $5384=$2;
11810       var $5385=(($5384+64)|0);
11811       var $5386=HEAP32[(($5385)>>2)];
11812       var $5387=$st;
11813       var $5388=(($5387+2)|0);
11814       var $5389=$5388;
11815       var $5390=HEAP16[(($5389)>>1)];
11816       var $5391=(($5390)&65535);
11817       var $5392=(($5386+($5391<<2))|0);
11818       var $5393=$5392;
11819       var $5394=$5393;
11820       var $5395=(($5394)|0);
11821       var $5396=HEAPF32[(($5395)>>2)];
11822       var $5397=$5396 != 0;
11823       if ($5397) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 200; break; }
11824     case 200:
11825       var $5399=$2;
11826       var $5400=(($5399+64)|0);
11827       var $5401=HEAP32[(($5400)>>2)];
11828       var $5402=$st;
11829       var $5403=(($5402+2)|0);
11830       var $5404=$5403;
11831       var $5405=HEAP16[(($5404)>>1)];
11832       var $5406=(($5405)&65535);
11833       var $5407=(($5401+($5406<<2))|0);
11834       var $5408=$5407;
11835       var $5409=$5408;
11836       var $5410=(($5409+4)|0);
11837       var $5411=HEAPF32[(($5410)>>2)];
11838       var $5412=$5411 != 0;
11839       if ($5412) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 201; break; }
11840     case 201:
11841       var $5414=$2;
11842       var $5415=(($5414+64)|0);
11843       var $5416=HEAP32[(($5415)>>2)];
11844       var $5417=$st;
11845       var $5418=(($5417+2)|0);
11846       var $5419=$5418;
11847       var $5420=HEAP16[(($5419)>>1)];
11848       var $5421=(($5420)&65535);
11849       var $5422=(($5416+($5421<<2))|0);
11850       var $5423=$5422;
11851       var $5424=$5423;
11852       var $5425=(($5424+8)|0);
11853       var $5426=HEAPF32[(($5425)>>2)];
11854       var $5427=$5426 != 0;
11855       var $5428=$5427 ^ 1;
11856       var $5430 = $5428;__label__ = 202; break;
11857     case 202:
11858       var $5430;
11859       var $5431=(($5430)&1);
11860       var $5432=(($5431)|0);
11861       var $5433=$2;
11862       var $5434=(($5433+64)|0);
11863       var $5435=HEAP32[(($5434)>>2)];
11864       var $5436=$st;
11865       var $5437=(($5436+6)|0);
11866       var $5438=$5437;
11867       var $5439=HEAP16[(($5438)>>1)];
11868       var $5440=(($5439)&65535);
11869       var $5441=(($5435+($5440<<2))|0);
11870       var $5442=$5441;
11871       var $5443=$5442;
11872       HEAPF32[(($5443)>>2)]=$5432;
11873       __label__ = 245; break;
11874     case 203:
11875       var $5445=$2;
11876       var $5446=(($5445+64)|0);
11877       var $5447=HEAP32[(($5446)>>2)];
11878       var $5448=$st;
11879       var $5449=(($5448+2)|0);
11880       var $5450=$5449;
11881       var $5451=HEAP16[(($5450)>>1)];
11882       var $5452=(($5451)&65535);
11883       var $5453=(($5447+($5452<<2))|0);
11884       var $5454=$5453;
11885       var $5455=$5454;
11886       var $5456=HEAP32[(($5455)>>2)];
11887       var $5457=(($5456)|0)!=0;
11888       if ($5457) { __label__ = 204; break; } else { var $5477 = 1;__label__ = 205; break; }
11889     case 204:
11890       var $5459=$2;
11891       var $5460=$2;
11892       var $5461=(($5460+64)|0);
11893       var $5462=HEAP32[(($5461)>>2)];
11894       var $5463=$st;
11895       var $5464=(($5463+2)|0);
11896       var $5465=$5464;
11897       var $5466=HEAP16[(($5465)>>1)];
11898       var $5467=(($5466)&65535);
11899       var $5468=(($5462+($5467<<2))|0);
11900       var $5469=$5468;
11901       var $5470=$5469;
11902       var $5471=HEAP32[(($5470)>>2)];
11903       var $5472=_prog_getstring($5459, $5471);
11904       var $5473=HEAP8[($5472)];
11905       var $5474=(($5473 << 24) >> 24)!=0;
11906       var $5475=$5474 ^ 1;
11907       var $5477 = $5475;__label__ = 205; break;
11908     case 205:
11909       var $5477;
11910       var $5478=(($5477)&1);
11911       var $5479=(($5478)|0);
11912       var $5480=$2;
11913       var $5481=(($5480+64)|0);
11914       var $5482=HEAP32[(($5481)>>2)];
11915       var $5483=$st;
11916       var $5484=(($5483+6)|0);
11917       var $5485=$5484;
11918       var $5486=HEAP16[(($5485)>>1)];
11919       var $5487=(($5486)&65535);
11920       var $5488=(($5482+($5487<<2))|0);
11921       var $5489=$5488;
11922       var $5490=$5489;
11923       HEAPF32[(($5490)>>2)]=$5479;
11924       __label__ = 245; break;
11925     case 206:
11926       var $5492=$2;
11927       var $5493=(($5492+64)|0);
11928       var $5494=HEAP32[(($5493)>>2)];
11929       var $5495=$st;
11930       var $5496=(($5495+2)|0);
11931       var $5497=$5496;
11932       var $5498=HEAP16[(($5497)>>1)];
11933       var $5499=(($5498)&65535);
11934       var $5500=(($5494+($5499<<2))|0);
11935       var $5501=$5500;
11936       var $5502=$5501;
11937       var $5503=HEAP32[(($5502)>>2)];
11938       var $5504=(($5503)|0)==0;
11939       var $5505=(($5504)&1);
11940       var $5506=(($5505)|0);
11941       var $5507=$2;
11942       var $5508=(($5507+64)|0);
11943       var $5509=HEAP32[(($5508)>>2)];
11944       var $5510=$st;
11945       var $5511=(($5510+6)|0);
11946       var $5512=$5511;
11947       var $5513=HEAP16[(($5512)>>1)];
11948       var $5514=(($5513)&65535);
11949       var $5515=(($5509+($5514<<2))|0);
11950       var $5516=$5515;
11951       var $5517=$5516;
11952       HEAPF32[(($5517)>>2)]=$5506;
11953       __label__ = 245; break;
11954     case 207:
11955       var $5519=$2;
11956       var $5520=(($5519+64)|0);
11957       var $5521=HEAP32[(($5520)>>2)];
11958       var $5522=$st;
11959       var $5523=(($5522+2)|0);
11960       var $5524=$5523;
11961       var $5525=HEAP16[(($5524)>>1)];
11962       var $5526=(($5525)&65535);
11963       var $5527=(($5521+($5526<<2))|0);
11964       var $5528=$5527;
11965       var $5529=$5528;
11966       var $5530=HEAP32[(($5529)>>2)];
11967       var $5531=(($5530)|0)!=0;
11968       var $5532=$5531 ^ 1;
11969       var $5533=(($5532)&1);
11970       var $5534=(($5533)|0);
11971       var $5535=$2;
11972       var $5536=(($5535+64)|0);
11973       var $5537=HEAP32[(($5536)>>2)];
11974       var $5538=$st;
11975       var $5539=(($5538+6)|0);
11976       var $5540=$5539;
11977       var $5541=HEAP16[(($5540)>>1)];
11978       var $5542=(($5541)&65535);
11979       var $5543=(($5537+($5542<<2))|0);
11980       var $5544=$5543;
11981       var $5545=$5544;
11982       HEAPF32[(($5545)>>2)]=$5534;
11983       __label__ = 245; break;
11984     case 208:
11985       var $5547=$2;
11986       var $5548=(($5547+64)|0);
11987       var $5549=HEAP32[(($5548)>>2)];
11988       var $5550=$st;
11989       var $5551=(($5550+2)|0);
11990       var $5552=$5551;
11991       var $5553=HEAP16[(($5552)>>1)];
11992       var $5554=(($5553)&65535);
11993       var $5555=(($5549+($5554<<2))|0);
11994       var $5556=$5555;
11995       var $5557=$5556;
11996       var $5558=HEAP32[(($5557)>>2)];
11997       var $5559=$5558 & 2147483647;
11998       var $5560=(($5559)|0)!=0;
11999       if ($5560) { __label__ = 209; break; } else { __label__ = 212; break; }
12000     case 209:
12001       var $5562=$st;
12002       var $5563=(($5562+4)|0);
12003       var $5564=$5563;
12004       var $5565=HEAP16[(($5564)>>1)];
12005       var $5566=(($5565 << 16) >> 16);
12006       var $5567=((($5566)-(1))|0);
12007       var $5568=$st;
12008       var $5569=(($5568+($5567<<3))|0);
12009       $st=$5569;
12010       var $5570=$jumpcount;
12011       var $5571=((($5570)+(1))|0);
12012       $jumpcount=$5571;
12013       var $5572=$5;
12014       var $5573=(($5571)|0) >= (($5572)|0);
12015       if ($5573) { __label__ = 210; break; } else { __label__ = 211; break; }
12016     case 210:
12017       var $5575=$2;
12018       var $5576=$2;
12019       var $5577=(($5576)|0);
12020       var $5578=HEAP32[(($5577)>>2)];
12021       var $5579=$jumpcount;
12022       _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));
12023       __label__ = 211; break;
12024     case 211:
12025       __label__ = 212; break;
12026     case 212:
12027       __label__ = 245; break;
12028     case 213:
12029       var $5583=$2;
12030       var $5584=(($5583+64)|0);
12031       var $5585=HEAP32[(($5584)>>2)];
12032       var $5586=$st;
12033       var $5587=(($5586+2)|0);
12034       var $5588=$5587;
12035       var $5589=HEAP16[(($5588)>>1)];
12036       var $5590=(($5589)&65535);
12037       var $5591=(($5585+($5590<<2))|0);
12038       var $5592=$5591;
12039       var $5593=$5592;
12040       var $5594=HEAP32[(($5593)>>2)];
12041       var $5595=$5594 & 2147483647;
12042       var $5596=(($5595)|0)!=0;
12043       if ($5596) { __label__ = 217; break; } else { __label__ = 214; break; }
12044     case 214:
12045       var $5598=$st;
12046       var $5599=(($5598+4)|0);
12047       var $5600=$5599;
12048       var $5601=HEAP16[(($5600)>>1)];
12049       var $5602=(($5601 << 16) >> 16);
12050       var $5603=((($5602)-(1))|0);
12051       var $5604=$st;
12052       var $5605=(($5604+($5603<<3))|0);
12053       $st=$5605;
12054       var $5606=$jumpcount;
12055       var $5607=((($5606)+(1))|0);
12056       $jumpcount=$5607;
12057       var $5608=$5;
12058       var $5609=(($5607)|0) >= (($5608)|0);
12059       if ($5609) { __label__ = 215; break; } else { __label__ = 216; break; }
12060     case 215:
12061       var $5611=$2;
12062       var $5612=$2;
12063       var $5613=(($5612)|0);
12064       var $5614=HEAP32[(($5613)>>2)];
12065       var $5615=$jumpcount;
12066       _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));
12067       __label__ = 216; break;
12068     case 216:
12069       __label__ = 217; break;
12070     case 217:
12071       __label__ = 245; break;
12072     case 218:
12073       var $5619=$st;
12074       var $5620=(($5619)|0);
12075       var $5621=HEAP16[(($5620)>>1)];
12076       var $5622=(($5621)&65535);
12077       var $5623=((($5622)-(51))|0);
12078       var $5624=$2;
12079       var $5625=(($5624+184)|0);
12080       HEAP32[(($5625)>>2)]=$5623;
12081       var $5626=$2;
12082       var $5627=(($5626+64)|0);
12083       var $5628=HEAP32[(($5627)>>2)];
12084       var $5629=$st;
12085       var $5630=(($5629+2)|0);
12086       var $5631=$5630;
12087       var $5632=HEAP16[(($5631)>>1)];
12088       var $5633=(($5632)&65535);
12089       var $5634=(($5628+($5633<<2))|0);
12090       var $5635=$5634;
12091       var $5636=$5635;
12092       var $5637=HEAP32[(($5636)>>2)];
12093       var $5638=(($5637)|0)!=0;
12094       if ($5638) { __label__ = 220; break; } else { __label__ = 219; break; }
12095     case 219:
12096       var $5640=$2;
12097       var $5641=$2;
12098       var $5642=(($5641)|0);
12099       var $5643=HEAP32[(($5642)>>2)];
12100       _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));
12101       __label__ = 220; break;
12102     case 220:
12103       var $5645=$2;
12104       var $5646=(($5645+64)|0);
12105       var $5647=HEAP32[(($5646)>>2)];
12106       var $5648=$st;
12107       var $5649=(($5648+2)|0);
12108       var $5650=$5649;
12109       var $5651=HEAP16[(($5650)>>1)];
12110       var $5652=(($5651)&65535);
12111       var $5653=(($5647+($5652<<2))|0);
12112       var $5654=$5653;
12113       var $5655=$5654;
12114       var $5656=HEAP32[(($5655)>>2)];
12115       var $5657=(($5656)|0)!=0;
12116       if ($5657) { __label__ = 221; break; } else { __label__ = 222; break; }
12117     case 221:
12118       var $5659=$2;
12119       var $5660=(($5659+64)|0);
12120       var $5661=HEAP32[(($5660)>>2)];
12121       var $5662=$st;
12122       var $5663=(($5662+2)|0);
12123       var $5664=$5663;
12124       var $5665=HEAP16[(($5664)>>1)];
12125       var $5666=(($5665)&65535);
12126       var $5667=(($5661+($5666<<2))|0);
12127       var $5668=$5667;
12128       var $5669=$5668;
12129       var $5670=HEAP32[(($5669)>>2)];
12130       var $5671=$2;
12131       var $5672=(($5671+44)|0);
12132       var $5673=HEAP32[(($5672)>>2)];
12133       var $5674=(($5670)>>>0) >= (($5673)>>>0);
12134       if ($5674) { __label__ = 222; break; } else { __label__ = 223; break; }
12135     case 222:
12136       var $5676=$2;
12137       var $5677=$2;
12138       var $5678=(($5677)|0);
12139       var $5679=HEAP32[(($5678)>>2)];
12140       _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));
12141       __label__ = 488; break;
12142     case 223:
12143       var $5681=$2;
12144       var $5682=(($5681+64)|0);
12145       var $5683=HEAP32[(($5682)>>2)];
12146       var $5684=$st;
12147       var $5685=(($5684+2)|0);
12148       var $5686=$5685;
12149       var $5687=HEAP16[(($5686)>>1)];
12150       var $5688=(($5687)&65535);
12151       var $5689=(($5683+($5688<<2))|0);
12152       var $5690=$5689;
12153       var $5691=$5690;
12154       var $5692=HEAP32[(($5691)>>2)];
12155       var $5693=$2;
12156       var $5694=(($5693+40)|0);
12157       var $5695=HEAP32[(($5694)>>2)];
12158       var $5696=(($5695+($5692)*(36))|0);
12159       $newf1=$5696;
12160       var $5697=$newf1;
12161       var $5698=(($5697+12)|0);
12162       var $5699=HEAP32[(($5698)>>2)];
12163       var $5700=((($5699)+(1))|0);
12164       HEAP32[(($5698)>>2)]=$5700;
12165       var $5701=$st;
12166       var $5702=$2;
12167       var $5703=(($5702+4)|0);
12168       var $5704=HEAP32[(($5703)>>2)];
12169       var $5705=$5701;
12170       var $5706=$5704;
12171       var $5707=((($5705)-($5706))|0);
12172       var $5708=((((($5707)|0))/(8))&-1);
12173       var $5709=((($5708)+(1))|0);
12174       var $5710=$2;
12175       var $5711=(($5710+176)|0);
12176       HEAP32[(($5711)>>2)]=$5709;
12177       var $5712=$newf1;
12178       var $5713=(($5712)|0);
12179       var $5714=HEAP32[(($5713)>>2)];
12180       var $5715=(($5714)|0) < 0;
12181       if ($5715) { __label__ = 224; break; } else { __label__ = 229; break; }
12182     case 224:
12183       var $5717=$newf1;
12184       var $5718=(($5717)|0);
12185       var $5719=HEAP32[(($5718)>>2)];
12186       var $5720=(((-$5719))|0);
12187       $builtinnumber4=$5720;
12188       var $5721=$builtinnumber4;
12189       var $5722=$2;
12190       var $5723=(($5722+132)|0);
12191       var $5724=HEAP32[(($5723)>>2)];
12192       var $5725=(($5721)>>>0) < (($5724)>>>0);
12193       if ($5725) { __label__ = 225; break; } else { __label__ = 227; break; }
12194     case 225:
12195       var $5727=$builtinnumber4;
12196       var $5728=$2;
12197       var $5729=(($5728+128)|0);
12198       var $5730=HEAP32[(($5729)>>2)];
12199       var $5731=(($5730+($5727<<2))|0);
12200       var $5732=HEAP32[(($5731)>>2)];
12201       var $5733=(($5732)|0)!=0;
12202       if ($5733) { __label__ = 226; break; } else { __label__ = 227; break; }
12203     case 226:
12204       var $5735=$builtinnumber4;
12205       var $5736=$2;
12206       var $5737=(($5736+128)|0);
12207       var $5738=HEAP32[(($5737)>>2)];
12208       var $5739=(($5738+($5735<<2))|0);
12209       var $5740=HEAP32[(($5739)>>2)];
12210       var $5741=$2;
12211       var $5742=FUNCTION_TABLE[$5740]($5741);
12212       __label__ = 228; break;
12213     case 227:
12214       var $5744=$2;
12215       var $5745=$builtinnumber4;
12216       var $5746=$2;
12217       var $5747=(($5746)|0);
12218       var $5748=HEAP32[(($5747)>>2)];
12219       _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));
12220       __label__ = 228; break;
12221     case 228:
12222       __label__ = 230; break;
12223     case 229:
12224       var $5751=$2;
12225       var $5752=(($5751+4)|0);
12226       var $5753=HEAP32[(($5752)>>2)];
12227       var $5754=$2;
12228       var $5755=$newf1;
12229       var $5756=_prog_enterfunction($5754, $5755);
12230       var $5757=(($5753+($5756<<3))|0);
12231       var $5758=((($5757)-(8))|0);
12232       $st=$5758;
12233       __label__ = 230; break;
12234     case 230:
12235       var $5760=$2;
12236       var $5761=(($5760+112)|0);
12237       var $5762=HEAP32[(($5761)>>2)];
12238       var $5763=(($5762)|0)!=0;
12239       if ($5763) { __label__ = 231; break; } else { __label__ = 232; break; }
12240     case 231:
12241       __label__ = 488; break;
12242     case 232:
12243       __label__ = 245; break;
12244     case 233:
12245       var $5767=$2;
12246       var $5768=$2;
12247       var $5769=(($5768)|0);
12248       var $5770=HEAP32[(($5769)>>2)];
12249       _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));
12250       __label__ = 245; break;
12251     case 234:
12252       var $5772=$st;
12253       var $5773=(($5772+2)|0);
12254       var $5774=$5773;
12255       var $5775=HEAP16[(($5774)>>1)];
12256       var $5776=(($5775 << 16) >> 16);
12257       var $5777=((($5776)-(1))|0);
12258       var $5778=$st;
12259       var $5779=(($5778+($5777<<3))|0);
12260       $st=$5779;
12261       var $5780=$jumpcount;
12262       var $5781=((($5780)+(1))|0);
12263       $jumpcount=$5781;
12264       var $5782=(($5781)|0)==10000000;
12265       if ($5782) { __label__ = 235; break; } else { __label__ = 236; break; }
12266     case 235:
12267       var $5784=$2;
12268       var $5785=$2;
12269       var $5786=(($5785)|0);
12270       var $5787=HEAP32[(($5786)>>2)];
12271       var $5788=$jumpcount;
12272       _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));
12273       __label__ = 236; break;
12274     case 236:
12275       __label__ = 245; break;
12276     case 237:
12277       var $5791=$2;
12278       var $5792=(($5791+64)|0);
12279       var $5793=HEAP32[(($5792)>>2)];
12280       var $5794=$st;
12281       var $5795=(($5794+2)|0);
12282       var $5796=$5795;
12283       var $5797=HEAP16[(($5796)>>1)];
12284       var $5798=(($5797)&65535);
12285       var $5799=(($5793+($5798<<2))|0);
12286       var $5800=$5799;
12287       var $5801=$5800;
12288       var $5802=HEAP32[(($5801)>>2)];
12289       var $5803=$5802 & 2147483647;
12290       var $5804=(($5803)|0)!=0;
12291       if ($5804) { __label__ = 238; break; } else { var $5821 = 0;__label__ = 239; break; }
12292     case 238:
12293       var $5806=$2;
12294       var $5807=(($5806+64)|0);
12295       var $5808=HEAP32[(($5807)>>2)];
12296       var $5809=$st;
12297       var $5810=(($5809+4)|0);
12298       var $5811=$5810;
12299       var $5812=HEAP16[(($5811)>>1)];
12300       var $5813=(($5812)&65535);
12301       var $5814=(($5808+($5813<<2))|0);
12302       var $5815=$5814;
12303       var $5816=$5815;
12304       var $5817=HEAP32[(($5816)>>2)];
12305       var $5818=$5817 & 2147483647;
12306       var $5819=(($5818)|0)!=0;
12307       var $5821 = $5819;__label__ = 239; break;
12308     case 239:
12309       var $5821;
12310       var $5822=(($5821)&1);
12311       var $5823=(($5822)|0);
12312       var $5824=$2;
12313       var $5825=(($5824+64)|0);
12314       var $5826=HEAP32[(($5825)>>2)];
12315       var $5827=$st;
12316       var $5828=(($5827+6)|0);
12317       var $5829=$5828;
12318       var $5830=HEAP16[(($5829)>>1)];
12319       var $5831=(($5830)&65535);
12320       var $5832=(($5826+($5831<<2))|0);
12321       var $5833=$5832;
12322       var $5834=$5833;
12323       HEAPF32[(($5834)>>2)]=$5823;
12324       __label__ = 245; break;
12325     case 240:
12326       var $5836=$2;
12327       var $5837=(($5836+64)|0);
12328       var $5838=HEAP32[(($5837)>>2)];
12329       var $5839=$st;
12330       var $5840=(($5839+2)|0);
12331       var $5841=$5840;
12332       var $5842=HEAP16[(($5841)>>1)];
12333       var $5843=(($5842)&65535);
12334       var $5844=(($5838+($5843<<2))|0);
12335       var $5845=$5844;
12336       var $5846=$5845;
12337       var $5847=HEAP32[(($5846)>>2)];
12338       var $5848=$5847 & 2147483647;
12339       var $5849=(($5848)|0)!=0;
12340       if ($5849) { var $5866 = 1;__label__ = 242; break; } else { __label__ = 241; break; }
12341     case 241:
12342       var $5851=$2;
12343       var $5852=(($5851+64)|0);
12344       var $5853=HEAP32[(($5852)>>2)];
12345       var $5854=$st;
12346       var $5855=(($5854+4)|0);
12347       var $5856=$5855;
12348       var $5857=HEAP16[(($5856)>>1)];
12349       var $5858=(($5857)&65535);
12350       var $5859=(($5853+($5858<<2))|0);
12351       var $5860=$5859;
12352       var $5861=$5860;
12353       var $5862=HEAP32[(($5861)>>2)];
12354       var $5863=$5862 & 2147483647;
12355       var $5864=(($5863)|0)!=0;
12356       var $5866 = $5864;__label__ = 242; break;
12357     case 242:
12358       var $5866;
12359       var $5867=(($5866)&1);
12360       var $5868=(($5867)|0);
12361       var $5869=$2;
12362       var $5870=(($5869+64)|0);
12363       var $5871=HEAP32[(($5870)>>2)];
12364       var $5872=$st;
12365       var $5873=(($5872+6)|0);
12366       var $5874=$5873;
12367       var $5875=HEAP16[(($5874)>>1)];
12368       var $5876=(($5875)&65535);
12369       var $5877=(($5871+($5876<<2))|0);
12370       var $5878=$5877;
12371       var $5879=$5878;
12372       HEAPF32[(($5879)>>2)]=$5868;
12373       __label__ = 245; break;
12374     case 243:
12375       var $5881=$2;
12376       var $5882=(($5881+64)|0);
12377       var $5883=HEAP32[(($5882)>>2)];
12378       var $5884=$st;
12379       var $5885=(($5884+2)|0);
12380       var $5886=$5885;
12381       var $5887=HEAP16[(($5886)>>1)];
12382       var $5888=(($5887)&65535);
12383       var $5889=(($5883+($5888<<2))|0);
12384       var $5890=$5889;
12385       var $5891=$5890;
12386       var $5892=HEAPF32[(($5891)>>2)];
12387       var $5893=(($5892)&-1);
12388       var $5894=$2;
12389       var $5895=(($5894+64)|0);
12390       var $5896=HEAP32[(($5895)>>2)];
12391       var $5897=$st;
12392       var $5898=(($5897+4)|0);
12393       var $5899=$5898;
12394       var $5900=HEAP16[(($5899)>>1)];
12395       var $5901=(($5900)&65535);
12396       var $5902=(($5896+($5901<<2))|0);
12397       var $5903=$5902;
12398       var $5904=$5903;
12399       var $5905=HEAPF32[(($5904)>>2)];
12400       var $5906=(($5905)&-1);
12401       var $5907=$5893 & $5906;
12402       var $5908=(($5907)|0);
12403       var $5909=$2;
12404       var $5910=(($5909+64)|0);
12405       var $5911=HEAP32[(($5910)>>2)];
12406       var $5912=$st;
12407       var $5913=(($5912+6)|0);
12408       var $5914=$5913;
12409       var $5915=HEAP16[(($5914)>>1)];
12410       var $5916=(($5915)&65535);
12411       var $5917=(($5911+($5916<<2))|0);
12412       var $5918=$5917;
12413       var $5919=$5918;
12414       HEAPF32[(($5919)>>2)]=$5908;
12415       __label__ = 245; break;
12416     case 244:
12417       var $5921=$2;
12418       var $5922=(($5921+64)|0);
12419       var $5923=HEAP32[(($5922)>>2)];
12420       var $5924=$st;
12421       var $5925=(($5924+2)|0);
12422       var $5926=$5925;
12423       var $5927=HEAP16[(($5926)>>1)];
12424       var $5928=(($5927)&65535);
12425       var $5929=(($5923+($5928<<2))|0);
12426       var $5930=$5929;
12427       var $5931=$5930;
12428       var $5932=HEAPF32[(($5931)>>2)];
12429       var $5933=(($5932)&-1);
12430       var $5934=$2;
12431       var $5935=(($5934+64)|0);
12432       var $5936=HEAP32[(($5935)>>2)];
12433       var $5937=$st;
12434       var $5938=(($5937+4)|0);
12435       var $5939=$5938;
12436       var $5940=HEAP16[(($5939)>>1)];
12437       var $5941=(($5940)&65535);
12438       var $5942=(($5936+($5941<<2))|0);
12439       var $5943=$5942;
12440       var $5944=$5943;
12441       var $5945=HEAPF32[(($5944)>>2)];
12442       var $5946=(($5945)&-1);
12443       var $5947=$5933 | $5946;
12444       var $5948=(($5947)|0);
12445       var $5949=$2;
12446       var $5950=(($5949+64)|0);
12447       var $5951=HEAP32[(($5950)>>2)];
12448       var $5952=$st;
12449       var $5953=(($5952+6)|0);
12450       var $5954=$5953;
12451       var $5955=HEAP16[(($5954)>>1)];
12452       var $5956=(($5955)&65535);
12453       var $5957=(($5951+($5956<<2))|0);
12454       var $5958=$5957;
12455       var $5959=$5958;
12456       HEAPF32[(($5959)>>2)]=$5948;
12457       __label__ = 245; break;
12458     case 245:
12459       __label__ = 126; break;
12460     case 246:
12461       __label__ = 247; break;
12462     case 247:
12463       var $5963=$st;
12464       var $5964=(($5963+8)|0);
12465       $st=$5964;
12466       var $5965=$st;
12467       var $5966=$2;
12468       var $5967=(($5966+4)|0);
12469       var $5968=HEAP32[(($5967)>>2)];
12470       var $5969=$5965;
12471       var $5970=$5968;
12472       var $5971=((($5969)-($5970))|0);
12473       var $5972=((((($5971)|0))/(8))&-1);
12474       var $5973=$2;
12475       var $5974=(($5973+116)|0);
12476       var $5975=HEAP32[(($5974)>>2)];
12477       var $5976=(($5975+($5972<<2))|0);
12478       var $5977=HEAP32[(($5976)>>2)];
12479       var $5978=((($5977)+(1))|0);
12480       HEAP32[(($5976)>>2)]=$5978;
12481       var $5979=$st;
12482       var $5980=(($5979)|0);
12483       var $5981=HEAP16[(($5980)>>1)];
12484       var $5982=(($5981)&65535);
12485       if ((($5982)|0) == 0 || (($5982)|0) == 43) {
12486         __label__ = 249; break;
12487       }
12488       else if ((($5982)|0) == 1) {
12489         __label__ = 252; break;
12490       }
12491       else if ((($5982)|0) == 2) {
12492         __label__ = 253; break;
12493       }
12494       else if ((($5982)|0) == 3) {
12495         __label__ = 254; break;
12496       }
12497       else if ((($5982)|0) == 4) {
12498         __label__ = 255; break;
12499       }
12500       else if ((($5982)|0) == 5) {
12501         __label__ = 256; break;
12502       }
12503       else if ((($5982)|0) == 6) {
12504         __label__ = 260; break;
12505       }
12506       else if ((($5982)|0) == 7) {
12507         __label__ = 261; break;
12508       }
12509       else if ((($5982)|0) == 8) {
12510         __label__ = 262; break;
12511       }
12512       else if ((($5982)|0) == 9) {
12513         __label__ = 263; break;
12514       }
12515       else if ((($5982)|0) == 10) {
12516         __label__ = 264; break;
12517       }
12518       else if ((($5982)|0) == 11) {
12519         __label__ = 265; break;
12520       }
12521       else if ((($5982)|0) == 12) {
12522         __label__ = 269; break;
12523       }
12524       else if ((($5982)|0) == 13) {
12525         __label__ = 270; break;
12526       }
12527       else if ((($5982)|0) == 14) {
12528         __label__ = 271; break;
12529       }
12530       else if ((($5982)|0) == 15) {
12531         __label__ = 272; break;
12532       }
12533       else if ((($5982)|0) == 16) {
12534         __label__ = 273; break;
12535       }
12536       else if ((($5982)|0) == 17) {
12537         __label__ = 277; break;
12538       }
12539       else if ((($5982)|0) == 18) {
12540         __label__ = 278; break;
12541       }
12542       else if ((($5982)|0) == 19) {
12543         __label__ = 279; break;
12544       }
12545       else if ((($5982)|0) == 20) {
12546         __label__ = 280; break;
12547       }
12548       else if ((($5982)|0) == 21) {
12549         __label__ = 281; break;
12550       }
12551       else if ((($5982)|0) == 22) {
12552         __label__ = 282; break;
12553       }
12554       else if ((($5982)|0) == 23) {
12555         __label__ = 283; break;
12556       }
12557       else if ((($5982)|0) == 24 || (($5982)|0) == 26 || (($5982)|0) == 28 || (($5982)|0) == 27 || (($5982)|0) == 29) {
12558         __label__ = 284; break;
12559       }
12560       else if ((($5982)|0) == 25) {
12561         __label__ = 290; break;
12562       }
12563       else if ((($5982)|0) == 30) {
12564         __label__ = 297; break;
12565       }
12566       else if ((($5982)|0) == 31 || (($5982)|0) == 33 || (($5982)|0) == 34 || (($5982)|0) == 35 || (($5982)|0) == 36) {
12567         __label__ = 303; break;
12568       }
12569       else if ((($5982)|0) == 32) {
12570         __label__ = 304; break;
12571       }
12572       else if ((($5982)|0) == 37 || (($5982)|0) == 39 || (($5982)|0) == 40 || (($5982)|0) == 41 || (($5982)|0) == 42) {
12573         __label__ = 305; break;
12574       }
12575       else if ((($5982)|0) == 38) {
12576         __label__ = 312; break;
12577       }
12578       else if ((($5982)|0) == 44) {
12579         __label__ = 319; break;
12580       }
12581       else if ((($5982)|0) == 45) {
12582         __label__ = 320; break;
12583       }
12584       else if ((($5982)|0) == 46) {
12585         __label__ = 324; break;
12586       }
12587       else if ((($5982)|0) == 47) {
12588         __label__ = 327; break;
12589       }
12590       else if ((($5982)|0) == 48) {
12591         __label__ = 328; break;
12592       }
12593       else if ((($5982)|0) == 49) {
12594         __label__ = 329; break;
12595       }
12596       else if ((($5982)|0) == 50) {
12597         __label__ = 334; break;
12598       }
12599       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) {
12600         __label__ = 339; break;
12601       }
12602       else if ((($5982)|0) == 60) {
12603         __label__ = 354; break;
12604       }
12605       else if ((($5982)|0) == 61) {
12606         __label__ = 355; break;
12607       }
12608       else if ((($5982)|0) == 62) {
12609         __label__ = 358; break;
12610       }
12611       else if ((($5982)|0) == 63) {
12612         __label__ = 361; break;
12613       }
12614       else if ((($5982)|0) == 64) {
12615         __label__ = 364; break;
12616       }
12617       else if ((($5982)|0) == 65) {
12618         __label__ = 365; break;
12619       }
12620       else {
12621       __label__ = 248; break;
12622       }
12623
12624     case 248:
12625       var $5984=$2;
12626       var $5985=$2;
12627       var $5986=(($5985)|0);
12628       var $5987=HEAP32[(($5986)>>2)];
12629       _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));
12630       __label__ = 488; break;
12631     case 249:
12632       var $5989=$2;
12633       var $5990=(($5989+64)|0);
12634       var $5991=HEAP32[(($5990)>>2)];
12635       var $5992=$st;
12636       var $5993=(($5992+2)|0);
12637       var $5994=$5993;
12638       var $5995=HEAP16[(($5994)>>1)];
12639       var $5996=(($5995)&65535);
12640       var $5997=(($5991+($5996<<2))|0);
12641       var $5998=$5997;
12642       var $5999=$5998;
12643       var $6000=(($5999)|0);
12644       var $6001=HEAP32[(($6000)>>2)];
12645       var $6002=$2;
12646       var $6003=(($6002+64)|0);
12647       var $6004=HEAP32[(($6003)>>2)];
12648       var $6005=(($6004+4)|0);
12649       var $6006=$6005;
12650       var $6007=$6006;
12651       var $6008=(($6007)|0);
12652       HEAP32[(($6008)>>2)]=$6001;
12653       var $6009=$2;
12654       var $6010=(($6009+64)|0);
12655       var $6011=HEAP32[(($6010)>>2)];
12656       var $6012=$st;
12657       var $6013=(($6012+2)|0);
12658       var $6014=$6013;
12659       var $6015=HEAP16[(($6014)>>1)];
12660       var $6016=(($6015)&65535);
12661       var $6017=(($6011+($6016<<2))|0);
12662       var $6018=$6017;
12663       var $6019=$6018;
12664       var $6020=(($6019+4)|0);
12665       var $6021=HEAP32[(($6020)>>2)];
12666       var $6022=$2;
12667       var $6023=(($6022+64)|0);
12668       var $6024=HEAP32[(($6023)>>2)];
12669       var $6025=(($6024+4)|0);
12670       var $6026=$6025;
12671       var $6027=$6026;
12672       var $6028=(($6027+4)|0);
12673       HEAP32[(($6028)>>2)]=$6021;
12674       var $6029=$2;
12675       var $6030=(($6029+64)|0);
12676       var $6031=HEAP32[(($6030)>>2)];
12677       var $6032=$st;
12678       var $6033=(($6032+2)|0);
12679       var $6034=$6033;
12680       var $6035=HEAP16[(($6034)>>1)];
12681       var $6036=(($6035)&65535);
12682       var $6037=(($6031+($6036<<2))|0);
12683       var $6038=$6037;
12684       var $6039=$6038;
12685       var $6040=(($6039+8)|0);
12686       var $6041=HEAP32[(($6040)>>2)];
12687       var $6042=$2;
12688       var $6043=(($6042+64)|0);
12689       var $6044=HEAP32[(($6043)>>2)];
12690       var $6045=(($6044+4)|0);
12691       var $6046=$6045;
12692       var $6047=$6046;
12693       var $6048=(($6047+8)|0);
12694       HEAP32[(($6048)>>2)]=$6041;
12695       var $6049=$2;
12696       var $6050=(($6049+4)|0);
12697       var $6051=HEAP32[(($6050)>>2)];
12698       var $6052=$2;
12699       var $6053=_prog_leavefunction($6052);
12700       var $6054=(($6051+($6053<<3))|0);
12701       $st=$6054;
12702       var $6055=$2;
12703       var $6056=(($6055+168)|0);
12704       var $6057=HEAP32[(($6056)>>2)];
12705       var $6058=(($6057)|0)!=0;
12706       if ($6058) { __label__ = 251; break; } else { __label__ = 250; break; }
12707     case 250:
12708       __label__ = 488; break;
12709     case 251:
12710       __label__ = 366; break;
12711     case 252:
12712       var $6062=$2;
12713       var $6063=(($6062+64)|0);
12714       var $6064=HEAP32[(($6063)>>2)];
12715       var $6065=$st;
12716       var $6066=(($6065+2)|0);
12717       var $6067=$6066;
12718       var $6068=HEAP16[(($6067)>>1)];
12719       var $6069=(($6068)&65535);
12720       var $6070=(($6064+($6069<<2))|0);
12721       var $6071=$6070;
12722       var $6072=$6071;
12723       var $6073=HEAPF32[(($6072)>>2)];
12724       var $6074=$2;
12725       var $6075=(($6074+64)|0);
12726       var $6076=HEAP32[(($6075)>>2)];
12727       var $6077=$st;
12728       var $6078=(($6077+4)|0);
12729       var $6079=$6078;
12730       var $6080=HEAP16[(($6079)>>1)];
12731       var $6081=(($6080)&65535);
12732       var $6082=(($6076+($6081<<2))|0);
12733       var $6083=$6082;
12734       var $6084=$6083;
12735       var $6085=HEAPF32[(($6084)>>2)];
12736       var $6086=($6073)*($6085);
12737       var $6087=$2;
12738       var $6088=(($6087+64)|0);
12739       var $6089=HEAP32[(($6088)>>2)];
12740       var $6090=$st;
12741       var $6091=(($6090+6)|0);
12742       var $6092=$6091;
12743       var $6093=HEAP16[(($6092)>>1)];
12744       var $6094=(($6093)&65535);
12745       var $6095=(($6089+($6094<<2))|0);
12746       var $6096=$6095;
12747       var $6097=$6096;
12748       HEAPF32[(($6097)>>2)]=$6086;
12749       __label__ = 366; break;
12750     case 253:
12751       var $6099=$2;
12752       var $6100=(($6099+64)|0);
12753       var $6101=HEAP32[(($6100)>>2)];
12754       var $6102=$st;
12755       var $6103=(($6102+2)|0);
12756       var $6104=$6103;
12757       var $6105=HEAP16[(($6104)>>1)];
12758       var $6106=(($6105)&65535);
12759       var $6107=(($6101+($6106<<2))|0);
12760       var $6108=$6107;
12761       var $6109=$6108;
12762       var $6110=(($6109)|0);
12763       var $6111=HEAPF32[(($6110)>>2)];
12764       var $6112=$2;
12765       var $6113=(($6112+64)|0);
12766       var $6114=HEAP32[(($6113)>>2)];
12767       var $6115=$st;
12768       var $6116=(($6115+4)|0);
12769       var $6117=$6116;
12770       var $6118=HEAP16[(($6117)>>1)];
12771       var $6119=(($6118)&65535);
12772       var $6120=(($6114+($6119<<2))|0);
12773       var $6121=$6120;
12774       var $6122=$6121;
12775       var $6123=(($6122)|0);
12776       var $6124=HEAPF32[(($6123)>>2)];
12777       var $6125=($6111)*($6124);
12778       var $6126=$2;
12779       var $6127=(($6126+64)|0);
12780       var $6128=HEAP32[(($6127)>>2)];
12781       var $6129=$st;
12782       var $6130=(($6129+2)|0);
12783       var $6131=$6130;
12784       var $6132=HEAP16[(($6131)>>1)];
12785       var $6133=(($6132)&65535);
12786       var $6134=(($6128+($6133<<2))|0);
12787       var $6135=$6134;
12788       var $6136=$6135;
12789       var $6137=(($6136+4)|0);
12790       var $6138=HEAPF32[(($6137)>>2)];
12791       var $6139=$2;
12792       var $6140=(($6139+64)|0);
12793       var $6141=HEAP32[(($6140)>>2)];
12794       var $6142=$st;
12795       var $6143=(($6142+4)|0);
12796       var $6144=$6143;
12797       var $6145=HEAP16[(($6144)>>1)];
12798       var $6146=(($6145)&65535);
12799       var $6147=(($6141+($6146<<2))|0);
12800       var $6148=$6147;
12801       var $6149=$6148;
12802       var $6150=(($6149+4)|0);
12803       var $6151=HEAPF32[(($6150)>>2)];
12804       var $6152=($6138)*($6151);
12805       var $6153=($6125)+($6152);
12806       var $6154=$2;
12807       var $6155=(($6154+64)|0);
12808       var $6156=HEAP32[(($6155)>>2)];
12809       var $6157=$st;
12810       var $6158=(($6157+2)|0);
12811       var $6159=$6158;
12812       var $6160=HEAP16[(($6159)>>1)];
12813       var $6161=(($6160)&65535);
12814       var $6162=(($6156+($6161<<2))|0);
12815       var $6163=$6162;
12816       var $6164=$6163;
12817       var $6165=(($6164+8)|0);
12818       var $6166=HEAPF32[(($6165)>>2)];
12819       var $6167=$2;
12820       var $6168=(($6167+64)|0);
12821       var $6169=HEAP32[(($6168)>>2)];
12822       var $6170=$st;
12823       var $6171=(($6170+4)|0);
12824       var $6172=$6171;
12825       var $6173=HEAP16[(($6172)>>1)];
12826       var $6174=(($6173)&65535);
12827       var $6175=(($6169+($6174<<2))|0);
12828       var $6176=$6175;
12829       var $6177=$6176;
12830       var $6178=(($6177+8)|0);
12831       var $6179=HEAPF32[(($6178)>>2)];
12832       var $6180=($6166)*($6179);
12833       var $6181=($6153)+($6180);
12834       var $6182=$2;
12835       var $6183=(($6182+64)|0);
12836       var $6184=HEAP32[(($6183)>>2)];
12837       var $6185=$st;
12838       var $6186=(($6185+6)|0);
12839       var $6187=$6186;
12840       var $6188=HEAP16[(($6187)>>1)];
12841       var $6189=(($6188)&65535);
12842       var $6190=(($6184+($6189<<2))|0);
12843       var $6191=$6190;
12844       var $6192=$6191;
12845       HEAPF32[(($6192)>>2)]=$6181;
12846       __label__ = 366; break;
12847     case 254:
12848       var $6194=$2;
12849       var $6195=(($6194+64)|0);
12850       var $6196=HEAP32[(($6195)>>2)];
12851       var $6197=$st;
12852       var $6198=(($6197+2)|0);
12853       var $6199=$6198;
12854       var $6200=HEAP16[(($6199)>>1)];
12855       var $6201=(($6200)&65535);
12856       var $6202=(($6196+($6201<<2))|0);
12857       var $6203=$6202;
12858       var $6204=$6203;
12859       var $6205=HEAPF32[(($6204)>>2)];
12860       var $6206=$2;
12861       var $6207=(($6206+64)|0);
12862       var $6208=HEAP32[(($6207)>>2)];
12863       var $6209=$st;
12864       var $6210=(($6209+4)|0);
12865       var $6211=$6210;
12866       var $6212=HEAP16[(($6211)>>1)];
12867       var $6213=(($6212)&65535);
12868       var $6214=(($6208+($6213<<2))|0);
12869       var $6215=$6214;
12870       var $6216=$6215;
12871       var $6217=(($6216)|0);
12872       var $6218=HEAPF32[(($6217)>>2)];
12873       var $6219=($6205)*($6218);
12874       var $6220=$2;
12875       var $6221=(($6220+64)|0);
12876       var $6222=HEAP32[(($6221)>>2)];
12877       var $6223=$st;
12878       var $6224=(($6223+6)|0);
12879       var $6225=$6224;
12880       var $6226=HEAP16[(($6225)>>1)];
12881       var $6227=(($6226)&65535);
12882       var $6228=(($6222+($6227<<2))|0);
12883       var $6229=$6228;
12884       var $6230=$6229;
12885       var $6231=(($6230)|0);
12886       HEAPF32[(($6231)>>2)]=$6219;
12887       var $6232=$2;
12888       var $6233=(($6232+64)|0);
12889       var $6234=HEAP32[(($6233)>>2)];
12890       var $6235=$st;
12891       var $6236=(($6235+2)|0);
12892       var $6237=$6236;
12893       var $6238=HEAP16[(($6237)>>1)];
12894       var $6239=(($6238)&65535);
12895       var $6240=(($6234+($6239<<2))|0);
12896       var $6241=$6240;
12897       var $6242=$6241;
12898       var $6243=HEAPF32[(($6242)>>2)];
12899       var $6244=$2;
12900       var $6245=(($6244+64)|0);
12901       var $6246=HEAP32[(($6245)>>2)];
12902       var $6247=$st;
12903       var $6248=(($6247+4)|0);
12904       var $6249=$6248;
12905       var $6250=HEAP16[(($6249)>>1)];
12906       var $6251=(($6250)&65535);
12907       var $6252=(($6246+($6251<<2))|0);
12908       var $6253=$6252;
12909       var $6254=$6253;
12910       var $6255=(($6254+4)|0);
12911       var $6256=HEAPF32[(($6255)>>2)];
12912       var $6257=($6243)*($6256);
12913       var $6258=$2;
12914       var $6259=(($6258+64)|0);
12915       var $6260=HEAP32[(($6259)>>2)];
12916       var $6261=$st;
12917       var $6262=(($6261+6)|0);
12918       var $6263=$6262;
12919       var $6264=HEAP16[(($6263)>>1)];
12920       var $6265=(($6264)&65535);
12921       var $6266=(($6260+($6265<<2))|0);
12922       var $6267=$6266;
12923       var $6268=$6267;
12924       var $6269=(($6268+4)|0);
12925       HEAPF32[(($6269)>>2)]=$6257;
12926       var $6270=$2;
12927       var $6271=(($6270+64)|0);
12928       var $6272=HEAP32[(($6271)>>2)];
12929       var $6273=$st;
12930       var $6274=(($6273+2)|0);
12931       var $6275=$6274;
12932       var $6276=HEAP16[(($6275)>>1)];
12933       var $6277=(($6276)&65535);
12934       var $6278=(($6272+($6277<<2))|0);
12935       var $6279=$6278;
12936       var $6280=$6279;
12937       var $6281=HEAPF32[(($6280)>>2)];
12938       var $6282=$2;
12939       var $6283=(($6282+64)|0);
12940       var $6284=HEAP32[(($6283)>>2)];
12941       var $6285=$st;
12942       var $6286=(($6285+4)|0);
12943       var $6287=$6286;
12944       var $6288=HEAP16[(($6287)>>1)];
12945       var $6289=(($6288)&65535);
12946       var $6290=(($6284+($6289<<2))|0);
12947       var $6291=$6290;
12948       var $6292=$6291;
12949       var $6293=(($6292+8)|0);
12950       var $6294=HEAPF32[(($6293)>>2)];
12951       var $6295=($6281)*($6294);
12952       var $6296=$2;
12953       var $6297=(($6296+64)|0);
12954       var $6298=HEAP32[(($6297)>>2)];
12955       var $6299=$st;
12956       var $6300=(($6299+6)|0);
12957       var $6301=$6300;
12958       var $6302=HEAP16[(($6301)>>1)];
12959       var $6303=(($6302)&65535);
12960       var $6304=(($6298+($6303<<2))|0);
12961       var $6305=$6304;
12962       var $6306=$6305;
12963       var $6307=(($6306+8)|0);
12964       HEAPF32[(($6307)>>2)]=$6295;
12965       __label__ = 366; break;
12966     case 255:
12967       var $6309=$2;
12968       var $6310=(($6309+64)|0);
12969       var $6311=HEAP32[(($6310)>>2)];
12970       var $6312=$st;
12971       var $6313=(($6312+4)|0);
12972       var $6314=$6313;
12973       var $6315=HEAP16[(($6314)>>1)];
12974       var $6316=(($6315)&65535);
12975       var $6317=(($6311+($6316<<2))|0);
12976       var $6318=$6317;
12977       var $6319=$6318;
12978       var $6320=HEAPF32[(($6319)>>2)];
12979       var $6321=$2;
12980       var $6322=(($6321+64)|0);
12981       var $6323=HEAP32[(($6322)>>2)];
12982       var $6324=$st;
12983       var $6325=(($6324+2)|0);
12984       var $6326=$6325;
12985       var $6327=HEAP16[(($6326)>>1)];
12986       var $6328=(($6327)&65535);
12987       var $6329=(($6323+($6328<<2))|0);
12988       var $6330=$6329;
12989       var $6331=$6330;
12990       var $6332=(($6331)|0);
12991       var $6333=HEAPF32[(($6332)>>2)];
12992       var $6334=($6320)*($6333);
12993       var $6335=$2;
12994       var $6336=(($6335+64)|0);
12995       var $6337=HEAP32[(($6336)>>2)];
12996       var $6338=$st;
12997       var $6339=(($6338+6)|0);
12998       var $6340=$6339;
12999       var $6341=HEAP16[(($6340)>>1)];
13000       var $6342=(($6341)&65535);
13001       var $6343=(($6337+($6342<<2))|0);
13002       var $6344=$6343;
13003       var $6345=$6344;
13004       var $6346=(($6345)|0);
13005       HEAPF32[(($6346)>>2)]=$6334;
13006       var $6347=$2;
13007       var $6348=(($6347+64)|0);
13008       var $6349=HEAP32[(($6348)>>2)];
13009       var $6350=$st;
13010       var $6351=(($6350+4)|0);
13011       var $6352=$6351;
13012       var $6353=HEAP16[(($6352)>>1)];
13013       var $6354=(($6353)&65535);
13014       var $6355=(($6349+($6354<<2))|0);
13015       var $6356=$6355;
13016       var $6357=$6356;
13017       var $6358=HEAPF32[(($6357)>>2)];
13018       var $6359=$2;
13019       var $6360=(($6359+64)|0);
13020       var $6361=HEAP32[(($6360)>>2)];
13021       var $6362=$st;
13022       var $6363=(($6362+2)|0);
13023       var $6364=$6363;
13024       var $6365=HEAP16[(($6364)>>1)];
13025       var $6366=(($6365)&65535);
13026       var $6367=(($6361+($6366<<2))|0);
13027       var $6368=$6367;
13028       var $6369=$6368;
13029       var $6370=(($6369+4)|0);
13030       var $6371=HEAPF32[(($6370)>>2)];
13031       var $6372=($6358)*($6371);
13032       var $6373=$2;
13033       var $6374=(($6373+64)|0);
13034       var $6375=HEAP32[(($6374)>>2)];
13035       var $6376=$st;
13036       var $6377=(($6376+6)|0);
13037       var $6378=$6377;
13038       var $6379=HEAP16[(($6378)>>1)];
13039       var $6380=(($6379)&65535);
13040       var $6381=(($6375+($6380<<2))|0);
13041       var $6382=$6381;
13042       var $6383=$6382;
13043       var $6384=(($6383+4)|0);
13044       HEAPF32[(($6384)>>2)]=$6372;
13045       var $6385=$2;
13046       var $6386=(($6385+64)|0);
13047       var $6387=HEAP32[(($6386)>>2)];
13048       var $6388=$st;
13049       var $6389=(($6388+4)|0);
13050       var $6390=$6389;
13051       var $6391=HEAP16[(($6390)>>1)];
13052       var $6392=(($6391)&65535);
13053       var $6393=(($6387+($6392<<2))|0);
13054       var $6394=$6393;
13055       var $6395=$6394;
13056       var $6396=HEAPF32[(($6395)>>2)];
13057       var $6397=$2;
13058       var $6398=(($6397+64)|0);
13059       var $6399=HEAP32[(($6398)>>2)];
13060       var $6400=$st;
13061       var $6401=(($6400+2)|0);
13062       var $6402=$6401;
13063       var $6403=HEAP16[(($6402)>>1)];
13064       var $6404=(($6403)&65535);
13065       var $6405=(($6399+($6404<<2))|0);
13066       var $6406=$6405;
13067       var $6407=$6406;
13068       var $6408=(($6407+8)|0);
13069       var $6409=HEAPF32[(($6408)>>2)];
13070       var $6410=($6396)*($6409);
13071       var $6411=$2;
13072       var $6412=(($6411+64)|0);
13073       var $6413=HEAP32[(($6412)>>2)];
13074       var $6414=$st;
13075       var $6415=(($6414+6)|0);
13076       var $6416=$6415;
13077       var $6417=HEAP16[(($6416)>>1)];
13078       var $6418=(($6417)&65535);
13079       var $6419=(($6413+($6418<<2))|0);
13080       var $6420=$6419;
13081       var $6421=$6420;
13082       var $6422=(($6421+8)|0);
13083       HEAPF32[(($6422)>>2)]=$6410;
13084       __label__ = 366; break;
13085     case 256:
13086       var $6424=$2;
13087       var $6425=(($6424+64)|0);
13088       var $6426=HEAP32[(($6425)>>2)];
13089       var $6427=$st;
13090       var $6428=(($6427+4)|0);
13091       var $6429=$6428;
13092       var $6430=HEAP16[(($6429)>>1)];
13093       var $6431=(($6430)&65535);
13094       var $6432=(($6426+($6431<<2))|0);
13095       var $6433=$6432;
13096       var $6434=$6433;
13097       var $6435=HEAPF32[(($6434)>>2)];
13098       var $6436=$6435 != 0;
13099       if ($6436) { __label__ = 257; break; } else { __label__ = 258; break; }
13100     case 257:
13101       var $6438=$2;
13102       var $6439=(($6438+64)|0);
13103       var $6440=HEAP32[(($6439)>>2)];
13104       var $6441=$st;
13105       var $6442=(($6441+2)|0);
13106       var $6443=$6442;
13107       var $6444=HEAP16[(($6443)>>1)];
13108       var $6445=(($6444)&65535);
13109       var $6446=(($6440+($6445<<2))|0);
13110       var $6447=$6446;
13111       var $6448=$6447;
13112       var $6449=HEAPF32[(($6448)>>2)];
13113       var $6450=$2;
13114       var $6451=(($6450+64)|0);
13115       var $6452=HEAP32[(($6451)>>2)];
13116       var $6453=$st;
13117       var $6454=(($6453+4)|0);
13118       var $6455=$6454;
13119       var $6456=HEAP16[(($6455)>>1)];
13120       var $6457=(($6456)&65535);
13121       var $6458=(($6452+($6457<<2))|0);
13122       var $6459=$6458;
13123       var $6460=$6459;
13124       var $6461=HEAPF32[(($6460)>>2)];
13125       var $6462=($6449)/($6461);
13126       var $6463=$2;
13127       var $6464=(($6463+64)|0);
13128       var $6465=HEAP32[(($6464)>>2)];
13129       var $6466=$st;
13130       var $6467=(($6466+6)|0);
13131       var $6468=$6467;
13132       var $6469=HEAP16[(($6468)>>1)];
13133       var $6470=(($6469)&65535);
13134       var $6471=(($6465+($6470<<2))|0);
13135       var $6472=$6471;
13136       var $6473=$6472;
13137       HEAPF32[(($6473)>>2)]=$6462;
13138       __label__ = 259; break;
13139     case 258:
13140       var $6475=$2;
13141       var $6476=(($6475+64)|0);
13142       var $6477=HEAP32[(($6476)>>2)];
13143       var $6478=$st;
13144       var $6479=(($6478+6)|0);
13145       var $6480=$6479;
13146       var $6481=HEAP16[(($6480)>>1)];
13147       var $6482=(($6481)&65535);
13148       var $6483=(($6477+($6482<<2))|0);
13149       var $6484=$6483;
13150       var $6485=$6484;
13151       HEAPF32[(($6485)>>2)]=0;
13152       __label__ = 259; break;
13153     case 259:
13154       __label__ = 366; break;
13155     case 260:
13156       var $6488=$2;
13157       var $6489=(($6488+64)|0);
13158       var $6490=HEAP32[(($6489)>>2)];
13159       var $6491=$st;
13160       var $6492=(($6491+2)|0);
13161       var $6493=$6492;
13162       var $6494=HEAP16[(($6493)>>1)];
13163       var $6495=(($6494)&65535);
13164       var $6496=(($6490+($6495<<2))|0);
13165       var $6497=$6496;
13166       var $6498=$6497;
13167       var $6499=HEAPF32[(($6498)>>2)];
13168       var $6500=$2;
13169       var $6501=(($6500+64)|0);
13170       var $6502=HEAP32[(($6501)>>2)];
13171       var $6503=$st;
13172       var $6504=(($6503+4)|0);
13173       var $6505=$6504;
13174       var $6506=HEAP16[(($6505)>>1)];
13175       var $6507=(($6506)&65535);
13176       var $6508=(($6502+($6507<<2))|0);
13177       var $6509=$6508;
13178       var $6510=$6509;
13179       var $6511=HEAPF32[(($6510)>>2)];
13180       var $6512=($6499)+($6511);
13181       var $6513=$2;
13182       var $6514=(($6513+64)|0);
13183       var $6515=HEAP32[(($6514)>>2)];
13184       var $6516=$st;
13185       var $6517=(($6516+6)|0);
13186       var $6518=$6517;
13187       var $6519=HEAP16[(($6518)>>1)];
13188       var $6520=(($6519)&65535);
13189       var $6521=(($6515+($6520<<2))|0);
13190       var $6522=$6521;
13191       var $6523=$6522;
13192       HEAPF32[(($6523)>>2)]=$6512;
13193       __label__ = 366; break;
13194     case 261:
13195       var $6525=$2;
13196       var $6526=(($6525+64)|0);
13197       var $6527=HEAP32[(($6526)>>2)];
13198       var $6528=$st;
13199       var $6529=(($6528+2)|0);
13200       var $6530=$6529;
13201       var $6531=HEAP16[(($6530)>>1)];
13202       var $6532=(($6531)&65535);
13203       var $6533=(($6527+($6532<<2))|0);
13204       var $6534=$6533;
13205       var $6535=$6534;
13206       var $6536=(($6535)|0);
13207       var $6537=HEAPF32[(($6536)>>2)];
13208       var $6538=$2;
13209       var $6539=(($6538+64)|0);
13210       var $6540=HEAP32[(($6539)>>2)];
13211       var $6541=$st;
13212       var $6542=(($6541+4)|0);
13213       var $6543=$6542;
13214       var $6544=HEAP16[(($6543)>>1)];
13215       var $6545=(($6544)&65535);
13216       var $6546=(($6540+($6545<<2))|0);
13217       var $6547=$6546;
13218       var $6548=$6547;
13219       var $6549=(($6548)|0);
13220       var $6550=HEAPF32[(($6549)>>2)];
13221       var $6551=($6537)+($6550);
13222       var $6552=$2;
13223       var $6553=(($6552+64)|0);
13224       var $6554=HEAP32[(($6553)>>2)];
13225       var $6555=$st;
13226       var $6556=(($6555+6)|0);
13227       var $6557=$6556;
13228       var $6558=HEAP16[(($6557)>>1)];
13229       var $6559=(($6558)&65535);
13230       var $6560=(($6554+($6559<<2))|0);
13231       var $6561=$6560;
13232       var $6562=$6561;
13233       var $6563=(($6562)|0);
13234       HEAPF32[(($6563)>>2)]=$6551;
13235       var $6564=$2;
13236       var $6565=(($6564+64)|0);
13237       var $6566=HEAP32[(($6565)>>2)];
13238       var $6567=$st;
13239       var $6568=(($6567+2)|0);
13240       var $6569=$6568;
13241       var $6570=HEAP16[(($6569)>>1)];
13242       var $6571=(($6570)&65535);
13243       var $6572=(($6566+($6571<<2))|0);
13244       var $6573=$6572;
13245       var $6574=$6573;
13246       var $6575=(($6574+4)|0);
13247       var $6576=HEAPF32[(($6575)>>2)];
13248       var $6577=$2;
13249       var $6578=(($6577+64)|0);
13250       var $6579=HEAP32[(($6578)>>2)];
13251       var $6580=$st;
13252       var $6581=(($6580+4)|0);
13253       var $6582=$6581;
13254       var $6583=HEAP16[(($6582)>>1)];
13255       var $6584=(($6583)&65535);
13256       var $6585=(($6579+($6584<<2))|0);
13257       var $6586=$6585;
13258       var $6587=$6586;
13259       var $6588=(($6587+4)|0);
13260       var $6589=HEAPF32[(($6588)>>2)];
13261       var $6590=($6576)+($6589);
13262       var $6591=$2;
13263       var $6592=(($6591+64)|0);
13264       var $6593=HEAP32[(($6592)>>2)];
13265       var $6594=$st;
13266       var $6595=(($6594+6)|0);
13267       var $6596=$6595;
13268       var $6597=HEAP16[(($6596)>>1)];
13269       var $6598=(($6597)&65535);
13270       var $6599=(($6593+($6598<<2))|0);
13271       var $6600=$6599;
13272       var $6601=$6600;
13273       var $6602=(($6601+4)|0);
13274       HEAPF32[(($6602)>>2)]=$6590;
13275       var $6603=$2;
13276       var $6604=(($6603+64)|0);
13277       var $6605=HEAP32[(($6604)>>2)];
13278       var $6606=$st;
13279       var $6607=(($6606+2)|0);
13280       var $6608=$6607;
13281       var $6609=HEAP16[(($6608)>>1)];
13282       var $6610=(($6609)&65535);
13283       var $6611=(($6605+($6610<<2))|0);
13284       var $6612=$6611;
13285       var $6613=$6612;
13286       var $6614=(($6613+8)|0);
13287       var $6615=HEAPF32[(($6614)>>2)];
13288       var $6616=$2;
13289       var $6617=(($6616+64)|0);
13290       var $6618=HEAP32[(($6617)>>2)];
13291       var $6619=$st;
13292       var $6620=(($6619+4)|0);
13293       var $6621=$6620;
13294       var $6622=HEAP16[(($6621)>>1)];
13295       var $6623=(($6622)&65535);
13296       var $6624=(($6618+($6623<<2))|0);
13297       var $6625=$6624;
13298       var $6626=$6625;
13299       var $6627=(($6626+8)|0);
13300       var $6628=HEAPF32[(($6627)>>2)];
13301       var $6629=($6615)+($6628);
13302       var $6630=$2;
13303       var $6631=(($6630+64)|0);
13304       var $6632=HEAP32[(($6631)>>2)];
13305       var $6633=$st;
13306       var $6634=(($6633+6)|0);
13307       var $6635=$6634;
13308       var $6636=HEAP16[(($6635)>>1)];
13309       var $6637=(($6636)&65535);
13310       var $6638=(($6632+($6637<<2))|0);
13311       var $6639=$6638;
13312       var $6640=$6639;
13313       var $6641=(($6640+8)|0);
13314       HEAPF32[(($6641)>>2)]=$6629;
13315       __label__ = 366; break;
13316     case 262:
13317       var $6643=$2;
13318       var $6644=(($6643+64)|0);
13319       var $6645=HEAP32[(($6644)>>2)];
13320       var $6646=$st;
13321       var $6647=(($6646+2)|0);
13322       var $6648=$6647;
13323       var $6649=HEAP16[(($6648)>>1)];
13324       var $6650=(($6649)&65535);
13325       var $6651=(($6645+($6650<<2))|0);
13326       var $6652=$6651;
13327       var $6653=$6652;
13328       var $6654=HEAPF32[(($6653)>>2)];
13329       var $6655=$2;
13330       var $6656=(($6655+64)|0);
13331       var $6657=HEAP32[(($6656)>>2)];
13332       var $6658=$st;
13333       var $6659=(($6658+4)|0);
13334       var $6660=$6659;
13335       var $6661=HEAP16[(($6660)>>1)];
13336       var $6662=(($6661)&65535);
13337       var $6663=(($6657+($6662<<2))|0);
13338       var $6664=$6663;
13339       var $6665=$6664;
13340       var $6666=HEAPF32[(($6665)>>2)];
13341       var $6667=($6654)-($6666);
13342       var $6668=$2;
13343       var $6669=(($6668+64)|0);
13344       var $6670=HEAP32[(($6669)>>2)];
13345       var $6671=$st;
13346       var $6672=(($6671+6)|0);
13347       var $6673=$6672;
13348       var $6674=HEAP16[(($6673)>>1)];
13349       var $6675=(($6674)&65535);
13350       var $6676=(($6670+($6675<<2))|0);
13351       var $6677=$6676;
13352       var $6678=$6677;
13353       HEAPF32[(($6678)>>2)]=$6667;
13354       __label__ = 366; break;
13355     case 263:
13356       var $6680=$2;
13357       var $6681=(($6680+64)|0);
13358       var $6682=HEAP32[(($6681)>>2)];
13359       var $6683=$st;
13360       var $6684=(($6683+2)|0);
13361       var $6685=$6684;
13362       var $6686=HEAP16[(($6685)>>1)];
13363       var $6687=(($6686)&65535);
13364       var $6688=(($6682+($6687<<2))|0);
13365       var $6689=$6688;
13366       var $6690=$6689;
13367       var $6691=(($6690)|0);
13368       var $6692=HEAPF32[(($6691)>>2)];
13369       var $6693=$2;
13370       var $6694=(($6693+64)|0);
13371       var $6695=HEAP32[(($6694)>>2)];
13372       var $6696=$st;
13373       var $6697=(($6696+4)|0);
13374       var $6698=$6697;
13375       var $6699=HEAP16[(($6698)>>1)];
13376       var $6700=(($6699)&65535);
13377       var $6701=(($6695+($6700<<2))|0);
13378       var $6702=$6701;
13379       var $6703=$6702;
13380       var $6704=(($6703)|0);
13381       var $6705=HEAPF32[(($6704)>>2)];
13382       var $6706=($6692)-($6705);
13383       var $6707=$2;
13384       var $6708=(($6707+64)|0);
13385       var $6709=HEAP32[(($6708)>>2)];
13386       var $6710=$st;
13387       var $6711=(($6710+6)|0);
13388       var $6712=$6711;
13389       var $6713=HEAP16[(($6712)>>1)];
13390       var $6714=(($6713)&65535);
13391       var $6715=(($6709+($6714<<2))|0);
13392       var $6716=$6715;
13393       var $6717=$6716;
13394       var $6718=(($6717)|0);
13395       HEAPF32[(($6718)>>2)]=$6706;
13396       var $6719=$2;
13397       var $6720=(($6719+64)|0);
13398       var $6721=HEAP32[(($6720)>>2)];
13399       var $6722=$st;
13400       var $6723=(($6722+2)|0);
13401       var $6724=$6723;
13402       var $6725=HEAP16[(($6724)>>1)];
13403       var $6726=(($6725)&65535);
13404       var $6727=(($6721+($6726<<2))|0);
13405       var $6728=$6727;
13406       var $6729=$6728;
13407       var $6730=(($6729+4)|0);
13408       var $6731=HEAPF32[(($6730)>>2)];
13409       var $6732=$2;
13410       var $6733=(($6732+64)|0);
13411       var $6734=HEAP32[(($6733)>>2)];
13412       var $6735=$st;
13413       var $6736=(($6735+4)|0);
13414       var $6737=$6736;
13415       var $6738=HEAP16[(($6737)>>1)];
13416       var $6739=(($6738)&65535);
13417       var $6740=(($6734+($6739<<2))|0);
13418       var $6741=$6740;
13419       var $6742=$6741;
13420       var $6743=(($6742+4)|0);
13421       var $6744=HEAPF32[(($6743)>>2)];
13422       var $6745=($6731)-($6744);
13423       var $6746=$2;
13424       var $6747=(($6746+64)|0);
13425       var $6748=HEAP32[(($6747)>>2)];
13426       var $6749=$st;
13427       var $6750=(($6749+6)|0);
13428       var $6751=$6750;
13429       var $6752=HEAP16[(($6751)>>1)];
13430       var $6753=(($6752)&65535);
13431       var $6754=(($6748+($6753<<2))|0);
13432       var $6755=$6754;
13433       var $6756=$6755;
13434       var $6757=(($6756+4)|0);
13435       HEAPF32[(($6757)>>2)]=$6745;
13436       var $6758=$2;
13437       var $6759=(($6758+64)|0);
13438       var $6760=HEAP32[(($6759)>>2)];
13439       var $6761=$st;
13440       var $6762=(($6761+2)|0);
13441       var $6763=$6762;
13442       var $6764=HEAP16[(($6763)>>1)];
13443       var $6765=(($6764)&65535);
13444       var $6766=(($6760+($6765<<2))|0);
13445       var $6767=$6766;
13446       var $6768=$6767;
13447       var $6769=(($6768+8)|0);
13448       var $6770=HEAPF32[(($6769)>>2)];
13449       var $6771=$2;
13450       var $6772=(($6771+64)|0);
13451       var $6773=HEAP32[(($6772)>>2)];
13452       var $6774=$st;
13453       var $6775=(($6774+4)|0);
13454       var $6776=$6775;
13455       var $6777=HEAP16[(($6776)>>1)];
13456       var $6778=(($6777)&65535);
13457       var $6779=(($6773+($6778<<2))|0);
13458       var $6780=$6779;
13459       var $6781=$6780;
13460       var $6782=(($6781+8)|0);
13461       var $6783=HEAPF32[(($6782)>>2)];
13462       var $6784=($6770)-($6783);
13463       var $6785=$2;
13464       var $6786=(($6785+64)|0);
13465       var $6787=HEAP32[(($6786)>>2)];
13466       var $6788=$st;
13467       var $6789=(($6788+6)|0);
13468       var $6790=$6789;
13469       var $6791=HEAP16[(($6790)>>1)];
13470       var $6792=(($6791)&65535);
13471       var $6793=(($6787+($6792<<2))|0);
13472       var $6794=$6793;
13473       var $6795=$6794;
13474       var $6796=(($6795+8)|0);
13475       HEAPF32[(($6796)>>2)]=$6784;
13476       __label__ = 366; break;
13477     case 264:
13478       var $6798=$2;
13479       var $6799=(($6798+64)|0);
13480       var $6800=HEAP32[(($6799)>>2)];
13481       var $6801=$st;
13482       var $6802=(($6801+2)|0);
13483       var $6803=$6802;
13484       var $6804=HEAP16[(($6803)>>1)];
13485       var $6805=(($6804)&65535);
13486       var $6806=(($6800+($6805<<2))|0);
13487       var $6807=$6806;
13488       var $6808=$6807;
13489       var $6809=HEAPF32[(($6808)>>2)];
13490       var $6810=$2;
13491       var $6811=(($6810+64)|0);
13492       var $6812=HEAP32[(($6811)>>2)];
13493       var $6813=$st;
13494       var $6814=(($6813+4)|0);
13495       var $6815=$6814;
13496       var $6816=HEAP16[(($6815)>>1)];
13497       var $6817=(($6816)&65535);
13498       var $6818=(($6812+($6817<<2))|0);
13499       var $6819=$6818;
13500       var $6820=$6819;
13501       var $6821=HEAPF32[(($6820)>>2)];
13502       var $6822=$6809 == $6821;
13503       var $6823=(($6822)&1);
13504       var $6824=(($6823)|0);
13505       var $6825=$2;
13506       var $6826=(($6825+64)|0);
13507       var $6827=HEAP32[(($6826)>>2)];
13508       var $6828=$st;
13509       var $6829=(($6828+6)|0);
13510       var $6830=$6829;
13511       var $6831=HEAP16[(($6830)>>1)];
13512       var $6832=(($6831)&65535);
13513       var $6833=(($6827+($6832<<2))|0);
13514       var $6834=$6833;
13515       var $6835=$6834;
13516       HEAPF32[(($6835)>>2)]=$6824;
13517       __label__ = 366; break;
13518     case 265:
13519       var $6837=$2;
13520       var $6838=(($6837+64)|0);
13521       var $6839=HEAP32[(($6838)>>2)];
13522       var $6840=$st;
13523       var $6841=(($6840+2)|0);
13524       var $6842=$6841;
13525       var $6843=HEAP16[(($6842)>>1)];
13526       var $6844=(($6843)&65535);
13527       var $6845=(($6839+($6844<<2))|0);
13528       var $6846=$6845;
13529       var $6847=$6846;
13530       var $6848=(($6847)|0);
13531       var $6849=HEAPF32[(($6848)>>2)];
13532       var $6850=$2;
13533       var $6851=(($6850+64)|0);
13534       var $6852=HEAP32[(($6851)>>2)];
13535       var $6853=$st;
13536       var $6854=(($6853+4)|0);
13537       var $6855=$6854;
13538       var $6856=HEAP16[(($6855)>>1)];
13539       var $6857=(($6856)&65535);
13540       var $6858=(($6852+($6857<<2))|0);
13541       var $6859=$6858;
13542       var $6860=$6859;
13543       var $6861=(($6860)|0);
13544       var $6862=HEAPF32[(($6861)>>2)];
13545       var $6863=$6849 == $6862;
13546       if ($6863) { __label__ = 266; break; } else { var $6921 = 0;__label__ = 268; break; }
13547     case 266:
13548       var $6865=$2;
13549       var $6866=(($6865+64)|0);
13550       var $6867=HEAP32[(($6866)>>2)];
13551       var $6868=$st;
13552       var $6869=(($6868+2)|0);
13553       var $6870=$6869;
13554       var $6871=HEAP16[(($6870)>>1)];
13555       var $6872=(($6871)&65535);
13556       var $6873=(($6867+($6872<<2))|0);
13557       var $6874=$6873;
13558       var $6875=$6874;
13559       var $6876=(($6875+4)|0);
13560       var $6877=HEAPF32[(($6876)>>2)];
13561       var $6878=$2;
13562       var $6879=(($6878+64)|0);
13563       var $6880=HEAP32[(($6879)>>2)];
13564       var $6881=$st;
13565       var $6882=(($6881+4)|0);
13566       var $6883=$6882;
13567       var $6884=HEAP16[(($6883)>>1)];
13568       var $6885=(($6884)&65535);
13569       var $6886=(($6880+($6885<<2))|0);
13570       var $6887=$6886;
13571       var $6888=$6887;
13572       var $6889=(($6888+4)|0);
13573       var $6890=HEAPF32[(($6889)>>2)];
13574       var $6891=$6877 == $6890;
13575       if ($6891) { __label__ = 267; break; } else { var $6921 = 0;__label__ = 268; break; }
13576     case 267:
13577       var $6893=$2;
13578       var $6894=(($6893+64)|0);
13579       var $6895=HEAP32[(($6894)>>2)];
13580       var $6896=$st;
13581       var $6897=(($6896+2)|0);
13582       var $6898=$6897;
13583       var $6899=HEAP16[(($6898)>>1)];
13584       var $6900=(($6899)&65535);
13585       var $6901=(($6895+($6900<<2))|0);
13586       var $6902=$6901;
13587       var $6903=$6902;
13588       var $6904=(($6903+8)|0);
13589       var $6905=HEAPF32[(($6904)>>2)];
13590       var $6906=$2;
13591       var $6907=(($6906+64)|0);
13592       var $6908=HEAP32[(($6907)>>2)];
13593       var $6909=$st;
13594       var $6910=(($6909+4)|0);
13595       var $6911=$6910;
13596       var $6912=HEAP16[(($6911)>>1)];
13597       var $6913=(($6912)&65535);
13598       var $6914=(($6908+($6913<<2))|0);
13599       var $6915=$6914;
13600       var $6916=$6915;
13601       var $6917=(($6916+8)|0);
13602       var $6918=HEAPF32[(($6917)>>2)];
13603       var $6919=$6905 == $6918;
13604       var $6921 = $6919;__label__ = 268; break;
13605     case 268:
13606       var $6921;
13607       var $6922=(($6921)&1);
13608       var $6923=(($6922)|0);
13609       var $6924=$2;
13610       var $6925=(($6924+64)|0);
13611       var $6926=HEAP32[(($6925)>>2)];
13612       var $6927=$st;
13613       var $6928=(($6927+6)|0);
13614       var $6929=$6928;
13615       var $6930=HEAP16[(($6929)>>1)];
13616       var $6931=(($6930)&65535);
13617       var $6932=(($6926+($6931<<2))|0);
13618       var $6933=$6932;
13619       var $6934=$6933;
13620       HEAPF32[(($6934)>>2)]=$6923;
13621       __label__ = 366; break;
13622     case 269:
13623       var $6936=$2;
13624       var $6937=$2;
13625       var $6938=(($6937+64)|0);
13626       var $6939=HEAP32[(($6938)>>2)];
13627       var $6940=$st;
13628       var $6941=(($6940+2)|0);
13629       var $6942=$6941;
13630       var $6943=HEAP16[(($6942)>>1)];
13631       var $6944=(($6943)&65535);
13632       var $6945=(($6939+($6944<<2))|0);
13633       var $6946=$6945;
13634       var $6947=$6946;
13635       var $6948=HEAP32[(($6947)>>2)];
13636       var $6949=_prog_getstring($6936, $6948);
13637       var $6950=$2;
13638       var $6951=$2;
13639       var $6952=(($6951+64)|0);
13640       var $6953=HEAP32[(($6952)>>2)];
13641       var $6954=$st;
13642       var $6955=(($6954+4)|0);
13643       var $6956=$6955;
13644       var $6957=HEAP16[(($6956)>>1)];
13645       var $6958=(($6957)&65535);
13646       var $6959=(($6953+($6958<<2))|0);
13647       var $6960=$6959;
13648       var $6961=$6960;
13649       var $6962=HEAP32[(($6961)>>2)];
13650       var $6963=_prog_getstring($6950, $6962);
13651       var $6964=_strcmp($6949, $6963);
13652       var $6965=(($6964)|0)!=0;
13653       var $6966=$6965 ^ 1;
13654       var $6967=(($6966)&1);
13655       var $6968=(($6967)|0);
13656       var $6969=$2;
13657       var $6970=(($6969+64)|0);
13658       var $6971=HEAP32[(($6970)>>2)];
13659       var $6972=$st;
13660       var $6973=(($6972+6)|0);
13661       var $6974=$6973;
13662       var $6975=HEAP16[(($6974)>>1)];
13663       var $6976=(($6975)&65535);
13664       var $6977=(($6971+($6976<<2))|0);
13665       var $6978=$6977;
13666       var $6979=$6978;
13667       HEAPF32[(($6979)>>2)]=$6968;
13668       __label__ = 366; break;
13669     case 270:
13670       var $6981=$2;
13671       var $6982=(($6981+64)|0);
13672       var $6983=HEAP32[(($6982)>>2)];
13673       var $6984=$st;
13674       var $6985=(($6984+2)|0);
13675       var $6986=$6985;
13676       var $6987=HEAP16[(($6986)>>1)];
13677       var $6988=(($6987)&65535);
13678       var $6989=(($6983+($6988<<2))|0);
13679       var $6990=$6989;
13680       var $6991=$6990;
13681       var $6992=HEAP32[(($6991)>>2)];
13682       var $6993=$2;
13683       var $6994=(($6993+64)|0);
13684       var $6995=HEAP32[(($6994)>>2)];
13685       var $6996=$st;
13686       var $6997=(($6996+4)|0);
13687       var $6998=$6997;
13688       var $6999=HEAP16[(($6998)>>1)];
13689       var $7000=(($6999)&65535);
13690       var $7001=(($6995+($7000<<2))|0);
13691       var $7002=$7001;
13692       var $7003=$7002;
13693       var $7004=HEAP32[(($7003)>>2)];
13694       var $7005=(($6992)|0)==(($7004)|0);
13695       var $7006=(($7005)&1);
13696       var $7007=(($7006)|0);
13697       var $7008=$2;
13698       var $7009=(($7008+64)|0);
13699       var $7010=HEAP32[(($7009)>>2)];
13700       var $7011=$st;
13701       var $7012=(($7011+6)|0);
13702       var $7013=$7012;
13703       var $7014=HEAP16[(($7013)>>1)];
13704       var $7015=(($7014)&65535);
13705       var $7016=(($7010+($7015<<2))|0);
13706       var $7017=$7016;
13707       var $7018=$7017;
13708       HEAPF32[(($7018)>>2)]=$7007;
13709       __label__ = 366; break;
13710     case 271:
13711       var $7020=$2;
13712       var $7021=(($7020+64)|0);
13713       var $7022=HEAP32[(($7021)>>2)];
13714       var $7023=$st;
13715       var $7024=(($7023+2)|0);
13716       var $7025=$7024;
13717       var $7026=HEAP16[(($7025)>>1)];
13718       var $7027=(($7026)&65535);
13719       var $7028=(($7022+($7027<<2))|0);
13720       var $7029=$7028;
13721       var $7030=$7029;
13722       var $7031=HEAP32[(($7030)>>2)];
13723       var $7032=$2;
13724       var $7033=(($7032+64)|0);
13725       var $7034=HEAP32[(($7033)>>2)];
13726       var $7035=$st;
13727       var $7036=(($7035+4)|0);
13728       var $7037=$7036;
13729       var $7038=HEAP16[(($7037)>>1)];
13730       var $7039=(($7038)&65535);
13731       var $7040=(($7034+($7039<<2))|0);
13732       var $7041=$7040;
13733       var $7042=$7041;
13734       var $7043=HEAP32[(($7042)>>2)];
13735       var $7044=(($7031)|0)==(($7043)|0);
13736       var $7045=(($7044)&1);
13737       var $7046=(($7045)|0);
13738       var $7047=$2;
13739       var $7048=(($7047+64)|0);
13740       var $7049=HEAP32[(($7048)>>2)];
13741       var $7050=$st;
13742       var $7051=(($7050+6)|0);
13743       var $7052=$7051;
13744       var $7053=HEAP16[(($7052)>>1)];
13745       var $7054=(($7053)&65535);
13746       var $7055=(($7049+($7054<<2))|0);
13747       var $7056=$7055;
13748       var $7057=$7056;
13749       HEAPF32[(($7057)>>2)]=$7046;
13750       __label__ = 366; break;
13751     case 272:
13752       var $7059=$2;
13753       var $7060=(($7059+64)|0);
13754       var $7061=HEAP32[(($7060)>>2)];
13755       var $7062=$st;
13756       var $7063=(($7062+2)|0);
13757       var $7064=$7063;
13758       var $7065=HEAP16[(($7064)>>1)];
13759       var $7066=(($7065)&65535);
13760       var $7067=(($7061+($7066<<2))|0);
13761       var $7068=$7067;
13762       var $7069=$7068;
13763       var $7070=HEAPF32[(($7069)>>2)];
13764       var $7071=$2;
13765       var $7072=(($7071+64)|0);
13766       var $7073=HEAP32[(($7072)>>2)];
13767       var $7074=$st;
13768       var $7075=(($7074+4)|0);
13769       var $7076=$7075;
13770       var $7077=HEAP16[(($7076)>>1)];
13771       var $7078=(($7077)&65535);
13772       var $7079=(($7073+($7078<<2))|0);
13773       var $7080=$7079;
13774       var $7081=$7080;
13775       var $7082=HEAPF32[(($7081)>>2)];
13776       var $7083=$7070 != $7082;
13777       var $7084=(($7083)&1);
13778       var $7085=(($7084)|0);
13779       var $7086=$2;
13780       var $7087=(($7086+64)|0);
13781       var $7088=HEAP32[(($7087)>>2)];
13782       var $7089=$st;
13783       var $7090=(($7089+6)|0);
13784       var $7091=$7090;
13785       var $7092=HEAP16[(($7091)>>1)];
13786       var $7093=(($7092)&65535);
13787       var $7094=(($7088+($7093<<2))|0);
13788       var $7095=$7094;
13789       var $7096=$7095;
13790       HEAPF32[(($7096)>>2)]=$7085;
13791       __label__ = 366; break;
13792     case 273:
13793       var $7098=$2;
13794       var $7099=(($7098+64)|0);
13795       var $7100=HEAP32[(($7099)>>2)];
13796       var $7101=$st;
13797       var $7102=(($7101+2)|0);
13798       var $7103=$7102;
13799       var $7104=HEAP16[(($7103)>>1)];
13800       var $7105=(($7104)&65535);
13801       var $7106=(($7100+($7105<<2))|0);
13802       var $7107=$7106;
13803       var $7108=$7107;
13804       var $7109=(($7108)|0);
13805       var $7110=HEAPF32[(($7109)>>2)];
13806       var $7111=$2;
13807       var $7112=(($7111+64)|0);
13808       var $7113=HEAP32[(($7112)>>2)];
13809       var $7114=$st;
13810       var $7115=(($7114+4)|0);
13811       var $7116=$7115;
13812       var $7117=HEAP16[(($7116)>>1)];
13813       var $7118=(($7117)&65535);
13814       var $7119=(($7113+($7118<<2))|0);
13815       var $7120=$7119;
13816       var $7121=$7120;
13817       var $7122=(($7121)|0);
13818       var $7123=HEAPF32[(($7122)>>2)];
13819       var $7124=$7110 != $7123;
13820       if ($7124) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 274; break; }
13821     case 274:
13822       var $7126=$2;
13823       var $7127=(($7126+64)|0);
13824       var $7128=HEAP32[(($7127)>>2)];
13825       var $7129=$st;
13826       var $7130=(($7129+2)|0);
13827       var $7131=$7130;
13828       var $7132=HEAP16[(($7131)>>1)];
13829       var $7133=(($7132)&65535);
13830       var $7134=(($7128+($7133<<2))|0);
13831       var $7135=$7134;
13832       var $7136=$7135;
13833       var $7137=(($7136+4)|0);
13834       var $7138=HEAPF32[(($7137)>>2)];
13835       var $7139=$2;
13836       var $7140=(($7139+64)|0);
13837       var $7141=HEAP32[(($7140)>>2)];
13838       var $7142=$st;
13839       var $7143=(($7142+4)|0);
13840       var $7144=$7143;
13841       var $7145=HEAP16[(($7144)>>1)];
13842       var $7146=(($7145)&65535);
13843       var $7147=(($7141+($7146<<2))|0);
13844       var $7148=$7147;
13845       var $7149=$7148;
13846       var $7150=(($7149+4)|0);
13847       var $7151=HEAPF32[(($7150)>>2)];
13848       var $7152=$7138 != $7151;
13849       if ($7152) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 275; break; }
13850     case 275:
13851       var $7154=$2;
13852       var $7155=(($7154+64)|0);
13853       var $7156=HEAP32[(($7155)>>2)];
13854       var $7157=$st;
13855       var $7158=(($7157+2)|0);
13856       var $7159=$7158;
13857       var $7160=HEAP16[(($7159)>>1)];
13858       var $7161=(($7160)&65535);
13859       var $7162=(($7156+($7161<<2))|0);
13860       var $7163=$7162;
13861       var $7164=$7163;
13862       var $7165=(($7164+8)|0);
13863       var $7166=HEAPF32[(($7165)>>2)];
13864       var $7167=$2;
13865       var $7168=(($7167+64)|0);
13866       var $7169=HEAP32[(($7168)>>2)];
13867       var $7170=$st;
13868       var $7171=(($7170+4)|0);
13869       var $7172=$7171;
13870       var $7173=HEAP16[(($7172)>>1)];
13871       var $7174=(($7173)&65535);
13872       var $7175=(($7169+($7174<<2))|0);
13873       var $7176=$7175;
13874       var $7177=$7176;
13875       var $7178=(($7177+8)|0);
13876       var $7179=HEAPF32[(($7178)>>2)];
13877       var $7180=$7166 != $7179;
13878       var $7182 = $7180;__label__ = 276; break;
13879     case 276:
13880       var $7182;
13881       var $7183=(($7182)&1);
13882       var $7184=(($7183)|0);
13883       var $7185=$2;
13884       var $7186=(($7185+64)|0);
13885       var $7187=HEAP32[(($7186)>>2)];
13886       var $7188=$st;
13887       var $7189=(($7188+6)|0);
13888       var $7190=$7189;
13889       var $7191=HEAP16[(($7190)>>1)];
13890       var $7192=(($7191)&65535);
13891       var $7193=(($7187+($7192<<2))|0);
13892       var $7194=$7193;
13893       var $7195=$7194;
13894       HEAPF32[(($7195)>>2)]=$7184;
13895       __label__ = 366; break;
13896     case 277:
13897       var $7197=$2;
13898       var $7198=$2;
13899       var $7199=(($7198+64)|0);
13900       var $7200=HEAP32[(($7199)>>2)];
13901       var $7201=$st;
13902       var $7202=(($7201+2)|0);
13903       var $7203=$7202;
13904       var $7204=HEAP16[(($7203)>>1)];
13905       var $7205=(($7204)&65535);
13906       var $7206=(($7200+($7205<<2))|0);
13907       var $7207=$7206;
13908       var $7208=$7207;
13909       var $7209=HEAP32[(($7208)>>2)];
13910       var $7210=_prog_getstring($7197, $7209);
13911       var $7211=$2;
13912       var $7212=$2;
13913       var $7213=(($7212+64)|0);
13914       var $7214=HEAP32[(($7213)>>2)];
13915       var $7215=$st;
13916       var $7216=(($7215+4)|0);
13917       var $7217=$7216;
13918       var $7218=HEAP16[(($7217)>>1)];
13919       var $7219=(($7218)&65535);
13920       var $7220=(($7214+($7219<<2))|0);
13921       var $7221=$7220;
13922       var $7222=$7221;
13923       var $7223=HEAP32[(($7222)>>2)];
13924       var $7224=_prog_getstring($7211, $7223);
13925       var $7225=_strcmp($7210, $7224);
13926       var $7226=(($7225)|0)!=0;
13927       var $7227=$7226 ^ 1;
13928       var $7228=$7227 ^ 1;
13929       var $7229=(($7228)&1);
13930       var $7230=(($7229)|0);
13931       var $7231=$2;
13932       var $7232=(($7231+64)|0);
13933       var $7233=HEAP32[(($7232)>>2)];
13934       var $7234=$st;
13935       var $7235=(($7234+6)|0);
13936       var $7236=$7235;
13937       var $7237=HEAP16[(($7236)>>1)];
13938       var $7238=(($7237)&65535);
13939       var $7239=(($7233+($7238<<2))|0);
13940       var $7240=$7239;
13941       var $7241=$7240;
13942       HEAPF32[(($7241)>>2)]=$7230;
13943       __label__ = 366; break;
13944     case 278:
13945       var $7243=$2;
13946       var $7244=(($7243+64)|0);
13947       var $7245=HEAP32[(($7244)>>2)];
13948       var $7246=$st;
13949       var $7247=(($7246+2)|0);
13950       var $7248=$7247;
13951       var $7249=HEAP16[(($7248)>>1)];
13952       var $7250=(($7249)&65535);
13953       var $7251=(($7245+($7250<<2))|0);
13954       var $7252=$7251;
13955       var $7253=$7252;
13956       var $7254=HEAP32[(($7253)>>2)];
13957       var $7255=$2;
13958       var $7256=(($7255+64)|0);
13959       var $7257=HEAP32[(($7256)>>2)];
13960       var $7258=$st;
13961       var $7259=(($7258+4)|0);
13962       var $7260=$7259;
13963       var $7261=HEAP16[(($7260)>>1)];
13964       var $7262=(($7261)&65535);
13965       var $7263=(($7257+($7262<<2))|0);
13966       var $7264=$7263;
13967       var $7265=$7264;
13968       var $7266=HEAP32[(($7265)>>2)];
13969       var $7267=(($7254)|0)!=(($7266)|0);
13970       var $7268=(($7267)&1);
13971       var $7269=(($7268)|0);
13972       var $7270=$2;
13973       var $7271=(($7270+64)|0);
13974       var $7272=HEAP32[(($7271)>>2)];
13975       var $7273=$st;
13976       var $7274=(($7273+6)|0);
13977       var $7275=$7274;
13978       var $7276=HEAP16[(($7275)>>1)];
13979       var $7277=(($7276)&65535);
13980       var $7278=(($7272+($7277<<2))|0);
13981       var $7279=$7278;
13982       var $7280=$7279;
13983       HEAPF32[(($7280)>>2)]=$7269;
13984       __label__ = 366; break;
13985     case 279:
13986       var $7282=$2;
13987       var $7283=(($7282+64)|0);
13988       var $7284=HEAP32[(($7283)>>2)];
13989       var $7285=$st;
13990       var $7286=(($7285+2)|0);
13991       var $7287=$7286;
13992       var $7288=HEAP16[(($7287)>>1)];
13993       var $7289=(($7288)&65535);
13994       var $7290=(($7284+($7289<<2))|0);
13995       var $7291=$7290;
13996       var $7292=$7291;
13997       var $7293=HEAP32[(($7292)>>2)];
13998       var $7294=$2;
13999       var $7295=(($7294+64)|0);
14000       var $7296=HEAP32[(($7295)>>2)];
14001       var $7297=$st;
14002       var $7298=(($7297+4)|0);
14003       var $7299=$7298;
14004       var $7300=HEAP16[(($7299)>>1)];
14005       var $7301=(($7300)&65535);
14006       var $7302=(($7296+($7301<<2))|0);
14007       var $7303=$7302;
14008       var $7304=$7303;
14009       var $7305=HEAP32[(($7304)>>2)];
14010       var $7306=(($7293)|0)!=(($7305)|0);
14011       var $7307=(($7306)&1);
14012       var $7308=(($7307)|0);
14013       var $7309=$2;
14014       var $7310=(($7309+64)|0);
14015       var $7311=HEAP32[(($7310)>>2)];
14016       var $7312=$st;
14017       var $7313=(($7312+6)|0);
14018       var $7314=$7313;
14019       var $7315=HEAP16[(($7314)>>1)];
14020       var $7316=(($7315)&65535);
14021       var $7317=(($7311+($7316<<2))|0);
14022       var $7318=$7317;
14023       var $7319=$7318;
14024       HEAPF32[(($7319)>>2)]=$7308;
14025       __label__ = 366; break;
14026     case 280:
14027       var $7321=$2;
14028       var $7322=(($7321+64)|0);
14029       var $7323=HEAP32[(($7322)>>2)];
14030       var $7324=$st;
14031       var $7325=(($7324+2)|0);
14032       var $7326=$7325;
14033       var $7327=HEAP16[(($7326)>>1)];
14034       var $7328=(($7327)&65535);
14035       var $7329=(($7323+($7328<<2))|0);
14036       var $7330=$7329;
14037       var $7331=$7330;
14038       var $7332=HEAPF32[(($7331)>>2)];
14039       var $7333=$2;
14040       var $7334=(($7333+64)|0);
14041       var $7335=HEAP32[(($7334)>>2)];
14042       var $7336=$st;
14043       var $7337=(($7336+4)|0);
14044       var $7338=$7337;
14045       var $7339=HEAP16[(($7338)>>1)];
14046       var $7340=(($7339)&65535);
14047       var $7341=(($7335+($7340<<2))|0);
14048       var $7342=$7341;
14049       var $7343=$7342;
14050       var $7344=HEAPF32[(($7343)>>2)];
14051       var $7345=$7332 <= $7344;
14052       var $7346=(($7345)&1);
14053       var $7347=(($7346)|0);
14054       var $7348=$2;
14055       var $7349=(($7348+64)|0);
14056       var $7350=HEAP32[(($7349)>>2)];
14057       var $7351=$st;
14058       var $7352=(($7351+6)|0);
14059       var $7353=$7352;
14060       var $7354=HEAP16[(($7353)>>1)];
14061       var $7355=(($7354)&65535);
14062       var $7356=(($7350+($7355<<2))|0);
14063       var $7357=$7356;
14064       var $7358=$7357;
14065       HEAPF32[(($7358)>>2)]=$7347;
14066       __label__ = 366; break;
14067     case 281:
14068       var $7360=$2;
14069       var $7361=(($7360+64)|0);
14070       var $7362=HEAP32[(($7361)>>2)];
14071       var $7363=$st;
14072       var $7364=(($7363+2)|0);
14073       var $7365=$7364;
14074       var $7366=HEAP16[(($7365)>>1)];
14075       var $7367=(($7366)&65535);
14076       var $7368=(($7362+($7367<<2))|0);
14077       var $7369=$7368;
14078       var $7370=$7369;
14079       var $7371=HEAPF32[(($7370)>>2)];
14080       var $7372=$2;
14081       var $7373=(($7372+64)|0);
14082       var $7374=HEAP32[(($7373)>>2)];
14083       var $7375=$st;
14084       var $7376=(($7375+4)|0);
14085       var $7377=$7376;
14086       var $7378=HEAP16[(($7377)>>1)];
14087       var $7379=(($7378)&65535);
14088       var $7380=(($7374+($7379<<2))|0);
14089       var $7381=$7380;
14090       var $7382=$7381;
14091       var $7383=HEAPF32[(($7382)>>2)];
14092       var $7384=$7371 >= $7383;
14093       var $7385=(($7384)&1);
14094       var $7386=(($7385)|0);
14095       var $7387=$2;
14096       var $7388=(($7387+64)|0);
14097       var $7389=HEAP32[(($7388)>>2)];
14098       var $7390=$st;
14099       var $7391=(($7390+6)|0);
14100       var $7392=$7391;
14101       var $7393=HEAP16[(($7392)>>1)];
14102       var $7394=(($7393)&65535);
14103       var $7395=(($7389+($7394<<2))|0);
14104       var $7396=$7395;
14105       var $7397=$7396;
14106       HEAPF32[(($7397)>>2)]=$7386;
14107       __label__ = 366; break;
14108     case 282:
14109       var $7399=$2;
14110       var $7400=(($7399+64)|0);
14111       var $7401=HEAP32[(($7400)>>2)];
14112       var $7402=$st;
14113       var $7403=(($7402+2)|0);
14114       var $7404=$7403;
14115       var $7405=HEAP16[(($7404)>>1)];
14116       var $7406=(($7405)&65535);
14117       var $7407=(($7401+($7406<<2))|0);
14118       var $7408=$7407;
14119       var $7409=$7408;
14120       var $7410=HEAPF32[(($7409)>>2)];
14121       var $7411=$2;
14122       var $7412=(($7411+64)|0);
14123       var $7413=HEAP32[(($7412)>>2)];
14124       var $7414=$st;
14125       var $7415=(($7414+4)|0);
14126       var $7416=$7415;
14127       var $7417=HEAP16[(($7416)>>1)];
14128       var $7418=(($7417)&65535);
14129       var $7419=(($7413+($7418<<2))|0);
14130       var $7420=$7419;
14131       var $7421=$7420;
14132       var $7422=HEAPF32[(($7421)>>2)];
14133       var $7423=$7410 < $7422;
14134       var $7424=(($7423)&1);
14135       var $7425=(($7424)|0);
14136       var $7426=$2;
14137       var $7427=(($7426+64)|0);
14138       var $7428=HEAP32[(($7427)>>2)];
14139       var $7429=$st;
14140       var $7430=(($7429+6)|0);
14141       var $7431=$7430;
14142       var $7432=HEAP16[(($7431)>>1)];
14143       var $7433=(($7432)&65535);
14144       var $7434=(($7428+($7433<<2))|0);
14145       var $7435=$7434;
14146       var $7436=$7435;
14147       HEAPF32[(($7436)>>2)]=$7425;
14148       __label__ = 366; break;
14149     case 283:
14150       var $7438=$2;
14151       var $7439=(($7438+64)|0);
14152       var $7440=HEAP32[(($7439)>>2)];
14153       var $7441=$st;
14154       var $7442=(($7441+2)|0);
14155       var $7443=$7442;
14156       var $7444=HEAP16[(($7443)>>1)];
14157       var $7445=(($7444)&65535);
14158       var $7446=(($7440+($7445<<2))|0);
14159       var $7447=$7446;
14160       var $7448=$7447;
14161       var $7449=HEAPF32[(($7448)>>2)];
14162       var $7450=$2;
14163       var $7451=(($7450+64)|0);
14164       var $7452=HEAP32[(($7451)>>2)];
14165       var $7453=$st;
14166       var $7454=(($7453+4)|0);
14167       var $7455=$7454;
14168       var $7456=HEAP16[(($7455)>>1)];
14169       var $7457=(($7456)&65535);
14170       var $7458=(($7452+($7457<<2))|0);
14171       var $7459=$7458;
14172       var $7460=$7459;
14173       var $7461=HEAPF32[(($7460)>>2)];
14174       var $7462=$7449 > $7461;
14175       var $7463=(($7462)&1);
14176       var $7464=(($7463)|0);
14177       var $7465=$2;
14178       var $7466=(($7465+64)|0);
14179       var $7467=HEAP32[(($7466)>>2)];
14180       var $7468=$st;
14181       var $7469=(($7468+6)|0);
14182       var $7470=$7469;
14183       var $7471=HEAP16[(($7470)>>1)];
14184       var $7472=(($7471)&65535);
14185       var $7473=(($7467+($7472<<2))|0);
14186       var $7474=$7473;
14187       var $7475=$7474;
14188       HEAPF32[(($7475)>>2)]=$7464;
14189       __label__ = 366; break;
14190     case 284:
14191       var $7477=$2;
14192       var $7478=(($7477+64)|0);
14193       var $7479=HEAP32[(($7478)>>2)];
14194       var $7480=$st;
14195       var $7481=(($7480+2)|0);
14196       var $7482=$7481;
14197       var $7483=HEAP16[(($7482)>>1)];
14198       var $7484=(($7483)&65535);
14199       var $7485=(($7479+($7484<<2))|0);
14200       var $7486=$7485;
14201       var $7487=$7486;
14202       var $7488=HEAP32[(($7487)>>2)];
14203       var $7489=(($7488)|0) < 0;
14204       if ($7489) { __label__ = 286; break; } else { __label__ = 285; break; }
14205     case 285:
14206       var $7491=$2;
14207       var $7492=(($7491+64)|0);
14208       var $7493=HEAP32[(($7492)>>2)];
14209       var $7494=$st;
14210       var $7495=(($7494+2)|0);
14211       var $7496=$7495;
14212       var $7497=HEAP16[(($7496)>>1)];
14213       var $7498=(($7497)&65535);
14214       var $7499=(($7493+($7498<<2))|0);
14215       var $7500=$7499;
14216       var $7501=$7500;
14217       var $7502=HEAP32[(($7501)>>2)];
14218       var $7503=$2;
14219       var $7504=(($7503+140)|0);
14220       var $7505=HEAP32[(($7504)>>2)];
14221       var $7506=(($7502)|0) >= (($7505)|0);
14222       if ($7506) { __label__ = 286; break; } else { __label__ = 287; break; }
14223     case 286:
14224       var $7508=$2;
14225       var $7509=$2;
14226       var $7510=(($7509)|0);
14227       var $7511=HEAP32[(($7510)>>2)];
14228       _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));
14229       __label__ = 488; break;
14230     case 287:
14231       var $7513=$2;
14232       var $7514=(($7513+64)|0);
14233       var $7515=HEAP32[(($7514)>>2)];
14234       var $7516=$st;
14235       var $7517=(($7516+4)|0);
14236       var $7518=$7517;
14237       var $7519=HEAP16[(($7518)>>1)];
14238       var $7520=(($7519)&65535);
14239       var $7521=(($7515+($7520<<2))|0);
14240       var $7522=$7521;
14241       var $7523=$7522;
14242       var $7524=HEAP32[(($7523)>>2)];
14243       var $7525=$2;
14244       var $7526=(($7525+144)|0);
14245       var $7527=HEAP32[(($7526)>>2)];
14246       var $7528=(($7524)>>>0) >= (($7527)>>>0);
14247       if ($7528) { __label__ = 288; break; } else { __label__ = 289; break; }
14248     case 288:
14249       var $7530=$2;
14250       var $7531=$2;
14251       var $7532=(($7531)|0);
14252       var $7533=HEAP32[(($7532)>>2)];
14253       var $7534=$2;
14254       var $7535=(($7534+64)|0);
14255       var $7536=HEAP32[(($7535)>>2)];
14256       var $7537=$st;
14257       var $7538=(($7537+4)|0);
14258       var $7539=$7538;
14259       var $7540=HEAP16[(($7539)>>1)];
14260       var $7541=(($7540)&65535);
14261       var $7542=(($7536+($7541<<2))|0);
14262       var $7543=$7542;
14263       var $7544=$7543;
14264       var $7545=HEAP32[(($7544)>>2)];
14265       _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));
14266       __label__ = 488; break;
14267     case 289:
14268       var $7547=$2;
14269       var $7548=$2;
14270       var $7549=(($7548+64)|0);
14271       var $7550=HEAP32[(($7549)>>2)];
14272       var $7551=$st;
14273       var $7552=(($7551+2)|0);
14274       var $7553=$7552;
14275       var $7554=HEAP16[(($7553)>>1)];
14276       var $7555=(($7554)&65535);
14277       var $7556=(($7550+($7555<<2))|0);
14278       var $7557=$7556;
14279       var $7558=$7557;
14280       var $7559=HEAP32[(($7558)>>2)];
14281       var $7560=_prog_getedict($7547, $7559);
14282       $ed6=$7560;
14283       var $7561=$ed6;
14284       var $7562=$7561;
14285       var $7563=$2;
14286       var $7564=(($7563+64)|0);
14287       var $7565=HEAP32[(($7564)>>2)];
14288       var $7566=$st;
14289       var $7567=(($7566+4)|0);
14290       var $7568=$7567;
14291       var $7569=HEAP16[(($7568)>>1)];
14292       var $7570=(($7569)&65535);
14293       var $7571=(($7565+($7570<<2))|0);
14294       var $7572=$7571;
14295       var $7573=$7572;
14296       var $7574=HEAP32[(($7573)>>2)];
14297       var $7575=(($7562+($7574<<2))|0);
14298       var $7576=$7575;
14299       var $7577=$7576;
14300       var $7578=HEAP32[(($7577)>>2)];
14301       var $7579=$2;
14302       var $7580=(($7579+64)|0);
14303       var $7581=HEAP32[(($7580)>>2)];
14304       var $7582=$st;
14305       var $7583=(($7582+6)|0);
14306       var $7584=$7583;
14307       var $7585=HEAP16[(($7584)>>1)];
14308       var $7586=(($7585)&65535);
14309       var $7587=(($7581+($7586<<2))|0);
14310       var $7588=$7587;
14311       var $7589=$7588;
14312       HEAP32[(($7589)>>2)]=$7578;
14313       __label__ = 366; break;
14314     case 290:
14315       var $7591=$2;
14316       var $7592=(($7591+64)|0);
14317       var $7593=HEAP32[(($7592)>>2)];
14318       var $7594=$st;
14319       var $7595=(($7594+2)|0);
14320       var $7596=$7595;
14321       var $7597=HEAP16[(($7596)>>1)];
14322       var $7598=(($7597)&65535);
14323       var $7599=(($7593+($7598<<2))|0);
14324       var $7600=$7599;
14325       var $7601=$7600;
14326       var $7602=HEAP32[(($7601)>>2)];
14327       var $7603=(($7602)|0) < 0;
14328       if ($7603) { __label__ = 292; break; } else { __label__ = 291; break; }
14329     case 291:
14330       var $7605=$2;
14331       var $7606=(($7605+64)|0);
14332       var $7607=HEAP32[(($7606)>>2)];
14333       var $7608=$st;
14334       var $7609=(($7608+2)|0);
14335       var $7610=$7609;
14336       var $7611=HEAP16[(($7610)>>1)];
14337       var $7612=(($7611)&65535);
14338       var $7613=(($7607+($7612<<2))|0);
14339       var $7614=$7613;
14340       var $7615=$7614;
14341       var $7616=HEAP32[(($7615)>>2)];
14342       var $7617=$2;
14343       var $7618=(($7617+140)|0);
14344       var $7619=HEAP32[(($7618)>>2)];
14345       var $7620=(($7616)|0) >= (($7619)|0);
14346       if ($7620) { __label__ = 292; break; } else { __label__ = 293; break; }
14347     case 292:
14348       var $7622=$2;
14349       var $7623=$2;
14350       var $7624=(($7623)|0);
14351       var $7625=HEAP32[(($7624)>>2)];
14352       _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));
14353       __label__ = 488; break;
14354     case 293:
14355       var $7627=$2;
14356       var $7628=(($7627+64)|0);
14357       var $7629=HEAP32[(($7628)>>2)];
14358       var $7630=$st;
14359       var $7631=(($7630+4)|0);
14360       var $7632=$7631;
14361       var $7633=HEAP16[(($7632)>>1)];
14362       var $7634=(($7633)&65535);
14363       var $7635=(($7629+($7634<<2))|0);
14364       var $7636=$7635;
14365       var $7637=$7636;
14366       var $7638=HEAP32[(($7637)>>2)];
14367       var $7639=(($7638)|0) < 0;
14368       if ($7639) { __label__ = 295; break; } else { __label__ = 294; break; }
14369     case 294:
14370       var $7641=$2;
14371       var $7642=(($7641+64)|0);
14372       var $7643=HEAP32[(($7642)>>2)];
14373       var $7644=$st;
14374       var $7645=(($7644+4)|0);
14375       var $7646=$7645;
14376       var $7647=HEAP16[(($7646)>>1)];
14377       var $7648=(($7647)&65535);
14378       var $7649=(($7643+($7648<<2))|0);
14379       var $7650=$7649;
14380       var $7651=$7650;
14381       var $7652=HEAP32[(($7651)>>2)];
14382       var $7653=((($7652)+(3))|0);
14383       var $7654=$2;
14384       var $7655=(($7654+144)|0);
14385       var $7656=HEAP32[(($7655)>>2)];
14386       var $7657=(($7653)>>>0) > (($7656)>>>0);
14387       if ($7657) { __label__ = 295; break; } else { __label__ = 296; break; }
14388     case 295:
14389       var $7659=$2;
14390       var $7660=$2;
14391       var $7661=(($7660)|0);
14392       var $7662=HEAP32[(($7661)>>2)];
14393       var $7663=$2;
14394       var $7664=(($7663+64)|0);
14395       var $7665=HEAP32[(($7664)>>2)];
14396       var $7666=$st;
14397       var $7667=(($7666+4)|0);
14398       var $7668=$7667;
14399       var $7669=HEAP16[(($7668)>>1)];
14400       var $7670=(($7669)&65535);
14401       var $7671=(($7665+($7670<<2))|0);
14402       var $7672=$7671;
14403       var $7673=$7672;
14404       var $7674=HEAP32[(($7673)>>2)];
14405       var $7675=((($7674)+(2))|0);
14406       _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));
14407       __label__ = 488; break;
14408     case 296:
14409       var $7677=$2;
14410       var $7678=$2;
14411       var $7679=(($7678+64)|0);
14412       var $7680=HEAP32[(($7679)>>2)];
14413       var $7681=$st;
14414       var $7682=(($7681+2)|0);
14415       var $7683=$7682;
14416       var $7684=HEAP16[(($7683)>>1)];
14417       var $7685=(($7684)&65535);
14418       var $7686=(($7680+($7685<<2))|0);
14419       var $7687=$7686;
14420       var $7688=$7687;
14421       var $7689=HEAP32[(($7688)>>2)];
14422       var $7690=_prog_getedict($7677, $7689);
14423       $ed6=$7690;
14424       var $7691=$ed6;
14425       var $7692=$7691;
14426       var $7693=$2;
14427       var $7694=(($7693+64)|0);
14428       var $7695=HEAP32[(($7694)>>2)];
14429       var $7696=$st;
14430       var $7697=(($7696+4)|0);
14431       var $7698=$7697;
14432       var $7699=HEAP16[(($7698)>>1)];
14433       var $7700=(($7699)&65535);
14434       var $7701=(($7695+($7700<<2))|0);
14435       var $7702=$7701;
14436       var $7703=$7702;
14437       var $7704=HEAP32[(($7703)>>2)];
14438       var $7705=(($7692+($7704<<2))|0);
14439       var $7706=$7705;
14440       var $7707=$7706;
14441       var $7708=(($7707)|0);
14442       var $7709=HEAP32[(($7708)>>2)];
14443       var $7710=$2;
14444       var $7711=(($7710+64)|0);
14445       var $7712=HEAP32[(($7711)>>2)];
14446       var $7713=$st;
14447       var $7714=(($7713+6)|0);
14448       var $7715=$7714;
14449       var $7716=HEAP16[(($7715)>>1)];
14450       var $7717=(($7716)&65535);
14451       var $7718=(($7712+($7717<<2))|0);
14452       var $7719=$7718;
14453       var $7720=$7719;
14454       var $7721=(($7720)|0);
14455       HEAP32[(($7721)>>2)]=$7709;
14456       var $7722=$ed6;
14457       var $7723=$7722;
14458       var $7724=$2;
14459       var $7725=(($7724+64)|0);
14460       var $7726=HEAP32[(($7725)>>2)];
14461       var $7727=$st;
14462       var $7728=(($7727+4)|0);
14463       var $7729=$7728;
14464       var $7730=HEAP16[(($7729)>>1)];
14465       var $7731=(($7730)&65535);
14466       var $7732=(($7726+($7731<<2))|0);
14467       var $7733=$7732;
14468       var $7734=$7733;
14469       var $7735=HEAP32[(($7734)>>2)];
14470       var $7736=(($7723+($7735<<2))|0);
14471       var $7737=$7736;
14472       var $7738=$7737;
14473       var $7739=(($7738+4)|0);
14474       var $7740=HEAP32[(($7739)>>2)];
14475       var $7741=$2;
14476       var $7742=(($7741+64)|0);
14477       var $7743=HEAP32[(($7742)>>2)];
14478       var $7744=$st;
14479       var $7745=(($7744+6)|0);
14480       var $7746=$7745;
14481       var $7747=HEAP16[(($7746)>>1)];
14482       var $7748=(($7747)&65535);
14483       var $7749=(($7743+($7748<<2))|0);
14484       var $7750=$7749;
14485       var $7751=$7750;
14486       var $7752=(($7751+4)|0);
14487       HEAP32[(($7752)>>2)]=$7740;
14488       var $7753=$ed6;
14489       var $7754=$7753;
14490       var $7755=$2;
14491       var $7756=(($7755+64)|0);
14492       var $7757=HEAP32[(($7756)>>2)];
14493       var $7758=$st;
14494       var $7759=(($7758+4)|0);
14495       var $7760=$7759;
14496       var $7761=HEAP16[(($7760)>>1)];
14497       var $7762=(($7761)&65535);
14498       var $7763=(($7757+($7762<<2))|0);
14499       var $7764=$7763;
14500       var $7765=$7764;
14501       var $7766=HEAP32[(($7765)>>2)];
14502       var $7767=(($7754+($7766<<2))|0);
14503       var $7768=$7767;
14504       var $7769=$7768;
14505       var $7770=(($7769+8)|0);
14506       var $7771=HEAP32[(($7770)>>2)];
14507       var $7772=$2;
14508       var $7773=(($7772+64)|0);
14509       var $7774=HEAP32[(($7773)>>2)];
14510       var $7775=$st;
14511       var $7776=(($7775+6)|0);
14512       var $7777=$7776;
14513       var $7778=HEAP16[(($7777)>>1)];
14514       var $7779=(($7778)&65535);
14515       var $7780=(($7774+($7779<<2))|0);
14516       var $7781=$7780;
14517       var $7782=$7781;
14518       var $7783=(($7782+8)|0);
14519       HEAP32[(($7783)>>2)]=$7771;
14520       __label__ = 366; break;
14521     case 297:
14522       var $7785=$2;
14523       var $7786=(($7785+64)|0);
14524       var $7787=HEAP32[(($7786)>>2)];
14525       var $7788=$st;
14526       var $7789=(($7788+2)|0);
14527       var $7790=$7789;
14528       var $7791=HEAP16[(($7790)>>1)];
14529       var $7792=(($7791)&65535);
14530       var $7793=(($7787+($7792<<2))|0);
14531       var $7794=$7793;
14532       var $7795=$7794;
14533       var $7796=HEAP32[(($7795)>>2)];
14534       var $7797=(($7796)|0) < 0;
14535       if ($7797) { __label__ = 299; break; } else { __label__ = 298; break; }
14536     case 298:
14537       var $7799=$2;
14538       var $7800=(($7799+64)|0);
14539       var $7801=HEAP32[(($7800)>>2)];
14540       var $7802=$st;
14541       var $7803=(($7802+2)|0);
14542       var $7804=$7803;
14543       var $7805=HEAP16[(($7804)>>1)];
14544       var $7806=(($7805)&65535);
14545       var $7807=(($7801+($7806<<2))|0);
14546       var $7808=$7807;
14547       var $7809=$7808;
14548       var $7810=HEAP32[(($7809)>>2)];
14549       var $7811=$2;
14550       var $7812=(($7811+140)|0);
14551       var $7813=HEAP32[(($7812)>>2)];
14552       var $7814=(($7810)|0) >= (($7813)|0);
14553       if ($7814) { __label__ = 299; break; } else { __label__ = 300; break; }
14554     case 299:
14555       var $7816=$2;
14556       var $7817=$2;
14557       var $7818=(($7817)|0);
14558       var $7819=HEAP32[(($7818)>>2)];
14559       var $7820=$2;
14560       var $7821=(($7820+64)|0);
14561       var $7822=HEAP32[(($7821)>>2)];
14562       var $7823=$st;
14563       var $7824=(($7823+2)|0);
14564       var $7825=$7824;
14565       var $7826=HEAP16[(($7825)>>1)];
14566       var $7827=(($7826)&65535);
14567       var $7828=(($7822+($7827<<2))|0);
14568       var $7829=$7828;
14569       var $7830=$7829;
14570       var $7831=HEAP32[(($7830)>>2)];
14571       _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));
14572       __label__ = 488; break;
14573     case 300:
14574       var $7833=$2;
14575       var $7834=(($7833+64)|0);
14576       var $7835=HEAP32[(($7834)>>2)];
14577       var $7836=$st;
14578       var $7837=(($7836+4)|0);
14579       var $7838=$7837;
14580       var $7839=HEAP16[(($7838)>>1)];
14581       var $7840=(($7839)&65535);
14582       var $7841=(($7835+($7840<<2))|0);
14583       var $7842=$7841;
14584       var $7843=$7842;
14585       var $7844=HEAP32[(($7843)>>2)];
14586       var $7845=$2;
14587       var $7846=(($7845+144)|0);
14588       var $7847=HEAP32[(($7846)>>2)];
14589       var $7848=(($7844)>>>0) >= (($7847)>>>0);
14590       if ($7848) { __label__ = 301; break; } else { __label__ = 302; break; }
14591     case 301:
14592       var $7850=$2;
14593       var $7851=$2;
14594       var $7852=(($7851)|0);
14595       var $7853=HEAP32[(($7852)>>2)];
14596       var $7854=$2;
14597       var $7855=(($7854+64)|0);
14598       var $7856=HEAP32[(($7855)>>2)];
14599       var $7857=$st;
14600       var $7858=(($7857+4)|0);
14601       var $7859=$7858;
14602       var $7860=HEAP16[(($7859)>>1)];
14603       var $7861=(($7860)&65535);
14604       var $7862=(($7856+($7861<<2))|0);
14605       var $7863=$7862;
14606       var $7864=$7863;
14607       var $7865=HEAP32[(($7864)>>2)];
14608       _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));
14609       __label__ = 488; break;
14610     case 302:
14611       var $7867=$2;
14612       var $7868=$2;
14613       var $7869=(($7868+64)|0);
14614       var $7870=HEAP32[(($7869)>>2)];
14615       var $7871=$st;
14616       var $7872=(($7871+2)|0);
14617       var $7873=$7872;
14618       var $7874=HEAP16[(($7873)>>1)];
14619       var $7875=(($7874)&65535);
14620       var $7876=(($7870+($7875<<2))|0);
14621       var $7877=$7876;
14622       var $7878=$7877;
14623       var $7879=HEAP32[(($7878)>>2)];
14624       var $7880=_prog_getedict($7867, $7879);
14625       $ed6=$7880;
14626       var $7881=$ed6;
14627       var $7882=$7881;
14628       var $7883=$2;
14629       var $7884=(($7883+76)|0);
14630       var $7885=HEAP32[(($7884)>>2)];
14631       var $7886=$7882;
14632       var $7887=$7885;
14633       var $7888=((($7886)-($7887))|0);
14634       var $7889=((((($7888)|0))/(4))&-1);
14635       var $7890=$2;
14636       var $7891=(($7890+64)|0);
14637       var $7892=HEAP32[(($7891)>>2)];
14638       var $7893=$st;
14639       var $7894=(($7893+6)|0);
14640       var $7895=$7894;
14641       var $7896=HEAP16[(($7895)>>1)];
14642       var $7897=(($7896)&65535);
14643       var $7898=(($7892+($7897<<2))|0);
14644       var $7899=$7898;
14645       var $7900=$7899;
14646       HEAP32[(($7900)>>2)]=$7889;
14647       var $7901=$2;
14648       var $7902=(($7901+64)|0);
14649       var $7903=HEAP32[(($7902)>>2)];
14650       var $7904=$st;
14651       var $7905=(($7904+4)|0);
14652       var $7906=$7905;
14653       var $7907=HEAP16[(($7906)>>1)];
14654       var $7908=(($7907)&65535);
14655       var $7909=(($7903+($7908<<2))|0);
14656       var $7910=$7909;
14657       var $7911=$7910;
14658       var $7912=HEAP32[(($7911)>>2)];
14659       var $7913=$2;
14660       var $7914=(($7913+64)|0);
14661       var $7915=HEAP32[(($7914)>>2)];
14662       var $7916=$st;
14663       var $7917=(($7916+6)|0);
14664       var $7918=$7917;
14665       var $7919=HEAP16[(($7918)>>1)];
14666       var $7920=(($7919)&65535);
14667       var $7921=(($7915+($7920<<2))|0);
14668       var $7922=$7921;
14669       var $7923=$7922;
14670       var $7924=HEAP32[(($7923)>>2)];
14671       var $7925=((($7924)+($7912))|0);
14672       HEAP32[(($7923)>>2)]=$7925;
14673       __label__ = 366; break;
14674     case 303:
14675       var $7927=$2;
14676       var $7928=(($7927+64)|0);
14677       var $7929=HEAP32[(($7928)>>2)];
14678       var $7930=$st;
14679       var $7931=(($7930+2)|0);
14680       var $7932=$7931;
14681       var $7933=HEAP16[(($7932)>>1)];
14682       var $7934=(($7933)&65535);
14683       var $7935=(($7929+($7934<<2))|0);
14684       var $7936=$7935;
14685       var $7937=$7936;
14686       var $7938=HEAP32[(($7937)>>2)];
14687       var $7939=$2;
14688       var $7940=(($7939+64)|0);
14689       var $7941=HEAP32[(($7940)>>2)];
14690       var $7942=$st;
14691       var $7943=(($7942+4)|0);
14692       var $7944=$7943;
14693       var $7945=HEAP16[(($7944)>>1)];
14694       var $7946=(($7945)&65535);
14695       var $7947=(($7941+($7946<<2))|0);
14696       var $7948=$7947;
14697       var $7949=$7948;
14698       HEAP32[(($7949)>>2)]=$7938;
14699       __label__ = 366; break;
14700     case 304:
14701       var $7951=$2;
14702       var $7952=(($7951+64)|0);
14703       var $7953=HEAP32[(($7952)>>2)];
14704       var $7954=$st;
14705       var $7955=(($7954+2)|0);
14706       var $7956=$7955;
14707       var $7957=HEAP16[(($7956)>>1)];
14708       var $7958=(($7957)&65535);
14709       var $7959=(($7953+($7958<<2))|0);
14710       var $7960=$7959;
14711       var $7961=$7960;
14712       var $7962=(($7961)|0);
14713       var $7963=HEAP32[(($7962)>>2)];
14714       var $7964=$2;
14715       var $7965=(($7964+64)|0);
14716       var $7966=HEAP32[(($7965)>>2)];
14717       var $7967=$st;
14718       var $7968=(($7967+4)|0);
14719       var $7969=$7968;
14720       var $7970=HEAP16[(($7969)>>1)];
14721       var $7971=(($7970)&65535);
14722       var $7972=(($7966+($7971<<2))|0);
14723       var $7973=$7972;
14724       var $7974=$7973;
14725       var $7975=(($7974)|0);
14726       HEAP32[(($7975)>>2)]=$7963;
14727       var $7976=$2;
14728       var $7977=(($7976+64)|0);
14729       var $7978=HEAP32[(($7977)>>2)];
14730       var $7979=$st;
14731       var $7980=(($7979+2)|0);
14732       var $7981=$7980;
14733       var $7982=HEAP16[(($7981)>>1)];
14734       var $7983=(($7982)&65535);
14735       var $7984=(($7978+($7983<<2))|0);
14736       var $7985=$7984;
14737       var $7986=$7985;
14738       var $7987=(($7986+4)|0);
14739       var $7988=HEAP32[(($7987)>>2)];
14740       var $7989=$2;
14741       var $7990=(($7989+64)|0);
14742       var $7991=HEAP32[(($7990)>>2)];
14743       var $7992=$st;
14744       var $7993=(($7992+4)|0);
14745       var $7994=$7993;
14746       var $7995=HEAP16[(($7994)>>1)];
14747       var $7996=(($7995)&65535);
14748       var $7997=(($7991+($7996<<2))|0);
14749       var $7998=$7997;
14750       var $7999=$7998;
14751       var $8000=(($7999+4)|0);
14752       HEAP32[(($8000)>>2)]=$7988;
14753       var $8001=$2;
14754       var $8002=(($8001+64)|0);
14755       var $8003=HEAP32[(($8002)>>2)];
14756       var $8004=$st;
14757       var $8005=(($8004+2)|0);
14758       var $8006=$8005;
14759       var $8007=HEAP16[(($8006)>>1)];
14760       var $8008=(($8007)&65535);
14761       var $8009=(($8003+($8008<<2))|0);
14762       var $8010=$8009;
14763       var $8011=$8010;
14764       var $8012=(($8011+8)|0);
14765       var $8013=HEAP32[(($8012)>>2)];
14766       var $8014=$2;
14767       var $8015=(($8014+64)|0);
14768       var $8016=HEAP32[(($8015)>>2)];
14769       var $8017=$st;
14770       var $8018=(($8017+4)|0);
14771       var $8019=$8018;
14772       var $8020=HEAP16[(($8019)>>1)];
14773       var $8021=(($8020)&65535);
14774       var $8022=(($8016+($8021<<2))|0);
14775       var $8023=$8022;
14776       var $8024=$8023;
14777       var $8025=(($8024+8)|0);
14778       HEAP32[(($8025)>>2)]=$8013;
14779       __label__ = 366; break;
14780     case 305:
14781       var $8027=$2;
14782       var $8028=(($8027+64)|0);
14783       var $8029=HEAP32[(($8028)>>2)];
14784       var $8030=$st;
14785       var $8031=(($8030+4)|0);
14786       var $8032=$8031;
14787       var $8033=HEAP16[(($8032)>>1)];
14788       var $8034=(($8033)&65535);
14789       var $8035=(($8029+($8034<<2))|0);
14790       var $8036=$8035;
14791       var $8037=$8036;
14792       var $8038=HEAP32[(($8037)>>2)];
14793       var $8039=(($8038)|0) < 0;
14794       if ($8039) { __label__ = 307; break; } else { __label__ = 306; break; }
14795     case 306:
14796       var $8041=$2;
14797       var $8042=(($8041+64)|0);
14798       var $8043=HEAP32[(($8042)>>2)];
14799       var $8044=$st;
14800       var $8045=(($8044+4)|0);
14801       var $8046=$8045;
14802       var $8047=HEAP16[(($8046)>>1)];
14803       var $8048=(($8047)&65535);
14804       var $8049=(($8043+($8048<<2))|0);
14805       var $8050=$8049;
14806       var $8051=$8050;
14807       var $8052=HEAP32[(($8051)>>2)];
14808       var $8053=$2;
14809       var $8054=(($8053+80)|0);
14810       var $8055=HEAP32[(($8054)>>2)];
14811       var $8056=(($8052)>>>0) >= (($8055)>>>0);
14812       if ($8056) { __label__ = 307; break; } else { __label__ = 308; break; }
14813     case 307:
14814       var $8058=$2;
14815       var $8059=$2;
14816       var $8060=(($8059)|0);
14817       var $8061=HEAP32[(($8060)>>2)];
14818       var $8062=$2;
14819       var $8063=(($8062+64)|0);
14820       var $8064=HEAP32[(($8063)>>2)];
14821       var $8065=$st;
14822       var $8066=(($8065+4)|0);
14823       var $8067=$8066;
14824       var $8068=HEAP16[(($8067)>>1)];
14825       var $8069=(($8068)&65535);
14826       var $8070=(($8064+($8069<<2))|0);
14827       var $8071=$8070;
14828       var $8072=$8071;
14829       var $8073=HEAP32[(($8072)>>2)];
14830       _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));
14831       __label__ = 488; break;
14832     case 308:
14833       var $8075=$2;
14834       var $8076=(($8075+64)|0);
14835       var $8077=HEAP32[(($8076)>>2)];
14836       var $8078=$st;
14837       var $8079=(($8078+4)|0);
14838       var $8080=$8079;
14839       var $8081=HEAP16[(($8080)>>1)];
14840       var $8082=(($8081)&65535);
14841       var $8083=(($8077+($8082<<2))|0);
14842       var $8084=$8083;
14843       var $8085=$8084;
14844       var $8086=HEAP32[(($8085)>>2)];
14845       var $8087=$2;
14846       var $8088=(($8087+144)|0);
14847       var $8089=HEAP32[(($8088)>>2)];
14848       var $8090=(($8086)>>>0) < (($8089)>>>0);
14849       if ($8090) { __label__ = 309; break; } else { __label__ = 311; break; }
14850     case 309:
14851       var $8092=$2;
14852       var $8093=(($8092+148)|0);
14853       var $8094=HEAP8[($8093)];
14854       var $8095=(($8094) & 1);
14855       if ($8095) { __label__ = 311; break; } else { __label__ = 310; break; }
14856     case 310:
14857       var $8097=$2;
14858       var $8098=$2;
14859       var $8099=(($8098)|0);
14860       var $8100=HEAP32[(($8099)>>2)];
14861       var $8101=$2;
14862       var $8102=$2;
14863       var $8103=$2;
14864       var $8104=(($8103+64)|0);
14865       var $8105=HEAP32[(($8104)>>2)];
14866       var $8106=$st;
14867       var $8107=(($8106+4)|0);
14868       var $8108=$8107;
14869       var $8109=HEAP16[(($8108)>>1)];
14870       var $8110=(($8109)&65535);
14871       var $8111=(($8105+($8110<<2))|0);
14872       var $8112=$8111;
14873       var $8113=$8112;
14874       var $8114=HEAP32[(($8113)>>2)];
14875       var $8115=_prog_entfield($8102, $8114);
14876       var $8116=(($8115+4)|0);
14877       var $8117=HEAP32[(($8116)>>2)];
14878       var $8118=_prog_getstring($8101, $8117);
14879       var $8119=$2;
14880       var $8120=(($8119+64)|0);
14881       var $8121=HEAP32[(($8120)>>2)];
14882       var $8122=$st;
14883       var $8123=(($8122+4)|0);
14884       var $8124=$8123;
14885       var $8125=HEAP16[(($8124)>>1)];
14886       var $8126=(($8125)&65535);
14887       var $8127=(($8121+($8126<<2))|0);
14888       var $8128=$8127;
14889       var $8129=$8128;
14890       var $8130=HEAP32[(($8129)>>2)];
14891       _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));
14892       __label__ = 311; break;
14893     case 311:
14894       var $8132=$2;
14895       var $8133=(($8132+76)|0);
14896       var $8134=HEAP32[(($8133)>>2)];
14897       var $8135=$2;
14898       var $8136=(($8135+64)|0);
14899       var $8137=HEAP32[(($8136)>>2)];
14900       var $8138=$st;
14901       var $8139=(($8138+4)|0);
14902       var $8140=$8139;
14903       var $8141=HEAP16[(($8140)>>1)];
14904       var $8142=(($8141)&65535);
14905       var $8143=(($8137+($8142<<2))|0);
14906       var $8144=$8143;
14907       var $8145=$8144;
14908       var $8146=HEAP32[(($8145)>>2)];
14909       var $8147=(($8134+($8146<<2))|0);
14910       var $8148=$8147;
14911       $ptr7=$8148;
14912       var $8149=$2;
14913       var $8150=(($8149+64)|0);
14914       var $8151=HEAP32[(($8150)>>2)];
14915       var $8152=$st;
14916       var $8153=(($8152+2)|0);
14917       var $8154=$8153;
14918       var $8155=HEAP16[(($8154)>>1)];
14919       var $8156=(($8155)&65535);
14920       var $8157=(($8151+($8156<<2))|0);
14921       var $8158=$8157;
14922       var $8159=$8158;
14923       var $8160=HEAP32[(($8159)>>2)];
14924       var $8161=$ptr7;
14925       var $8162=$8161;
14926       HEAP32[(($8162)>>2)]=$8160;
14927       __label__ = 366; break;
14928     case 312:
14929       var $8164=$2;
14930       var $8165=(($8164+64)|0);
14931       var $8166=HEAP32[(($8165)>>2)];
14932       var $8167=$st;
14933       var $8168=(($8167+4)|0);
14934       var $8169=$8168;
14935       var $8170=HEAP16[(($8169)>>1)];
14936       var $8171=(($8170)&65535);
14937       var $8172=(($8166+($8171<<2))|0);
14938       var $8173=$8172;
14939       var $8174=$8173;
14940       var $8175=HEAP32[(($8174)>>2)];
14941       var $8176=(($8175)|0) < 0;
14942       if ($8176) { __label__ = 314; break; } else { __label__ = 313; break; }
14943     case 313:
14944       var $8178=$2;
14945       var $8179=(($8178+64)|0);
14946       var $8180=HEAP32[(($8179)>>2)];
14947       var $8181=$st;
14948       var $8182=(($8181+4)|0);
14949       var $8183=$8182;
14950       var $8184=HEAP16[(($8183)>>1)];
14951       var $8185=(($8184)&65535);
14952       var $8186=(($8180+($8185<<2))|0);
14953       var $8187=$8186;
14954       var $8188=$8187;
14955       var $8189=HEAP32[(($8188)>>2)];
14956       var $8190=((($8189)+(2))|0);
14957       var $8191=$2;
14958       var $8192=(($8191+80)|0);
14959       var $8193=HEAP32[(($8192)>>2)];
14960       var $8194=(($8190)>>>0) >= (($8193)>>>0);
14961       if ($8194) { __label__ = 314; break; } else { __label__ = 315; break; }
14962     case 314:
14963       var $8196=$2;
14964       var $8197=$2;
14965       var $8198=(($8197)|0);
14966       var $8199=HEAP32[(($8198)>>2)];
14967       var $8200=$2;
14968       var $8201=(($8200+64)|0);
14969       var $8202=HEAP32[(($8201)>>2)];
14970       var $8203=$st;
14971       var $8204=(($8203+4)|0);
14972       var $8205=$8204;
14973       var $8206=HEAP16[(($8205)>>1)];
14974       var $8207=(($8206)&65535);
14975       var $8208=(($8202+($8207<<2))|0);
14976       var $8209=$8208;
14977       var $8210=$8209;
14978       var $8211=HEAP32[(($8210)>>2)];
14979       _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));
14980       __label__ = 488; break;
14981     case 315:
14982       var $8213=$2;
14983       var $8214=(($8213+64)|0);
14984       var $8215=HEAP32[(($8214)>>2)];
14985       var $8216=$st;
14986       var $8217=(($8216+4)|0);
14987       var $8218=$8217;
14988       var $8219=HEAP16[(($8218)>>1)];
14989       var $8220=(($8219)&65535);
14990       var $8221=(($8215+($8220<<2))|0);
14991       var $8222=$8221;
14992       var $8223=$8222;
14993       var $8224=HEAP32[(($8223)>>2)];
14994       var $8225=$2;
14995       var $8226=(($8225+144)|0);
14996       var $8227=HEAP32[(($8226)>>2)];
14997       var $8228=(($8224)>>>0) < (($8227)>>>0);
14998       if ($8228) { __label__ = 316; break; } else { __label__ = 318; break; }
14999     case 316:
15000       var $8230=$2;
15001       var $8231=(($8230+148)|0);
15002       var $8232=HEAP8[($8231)];
15003       var $8233=(($8232) & 1);
15004       if ($8233) { __label__ = 318; break; } else { __label__ = 317; break; }
15005     case 317:
15006       var $8235=$2;
15007       var $8236=$2;
15008       var $8237=(($8236)|0);
15009       var $8238=HEAP32[(($8237)>>2)];
15010       var $8239=$2;
15011       var $8240=$2;
15012       var $8241=$2;
15013       var $8242=(($8241+64)|0);
15014       var $8243=HEAP32[(($8242)>>2)];
15015       var $8244=$st;
15016       var $8245=(($8244+4)|0);
15017       var $8246=$8245;
15018       var $8247=HEAP16[(($8246)>>1)];
15019       var $8248=(($8247)&65535);
15020       var $8249=(($8243+($8248<<2))|0);
15021       var $8250=$8249;
15022       var $8251=$8250;
15023       var $8252=HEAP32[(($8251)>>2)];
15024       var $8253=_prog_entfield($8240, $8252);
15025       var $8254=(($8253+4)|0);
15026       var $8255=HEAP32[(($8254)>>2)];
15027       var $8256=_prog_getstring($8239, $8255);
15028       var $8257=$2;
15029       var $8258=(($8257+64)|0);
15030       var $8259=HEAP32[(($8258)>>2)];
15031       var $8260=$st;
15032       var $8261=(($8260+4)|0);
15033       var $8262=$8261;
15034       var $8263=HEAP16[(($8262)>>1)];
15035       var $8264=(($8263)&65535);
15036       var $8265=(($8259+($8264<<2))|0);
15037       var $8266=$8265;
15038       var $8267=$8266;
15039       var $8268=HEAP32[(($8267)>>2)];
15040       _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));
15041       __label__ = 318; break;
15042     case 318:
15043       var $8270=$2;
15044       var $8271=(($8270+76)|0);
15045       var $8272=HEAP32[(($8271)>>2)];
15046       var $8273=$2;
15047       var $8274=(($8273+64)|0);
15048       var $8275=HEAP32[(($8274)>>2)];
15049       var $8276=$st;
15050       var $8277=(($8276+4)|0);
15051       var $8278=$8277;
15052       var $8279=HEAP16[(($8278)>>1)];
15053       var $8280=(($8279)&65535);
15054       var $8281=(($8275+($8280<<2))|0);
15055       var $8282=$8281;
15056       var $8283=$8282;
15057       var $8284=HEAP32[(($8283)>>2)];
15058       var $8285=(($8272+($8284<<2))|0);
15059       var $8286=$8285;
15060       $ptr7=$8286;
15061       var $8287=$2;
15062       var $8288=(($8287+64)|0);
15063       var $8289=HEAP32[(($8288)>>2)];
15064       var $8290=$st;
15065       var $8291=(($8290+2)|0);
15066       var $8292=$8291;
15067       var $8293=HEAP16[(($8292)>>1)];
15068       var $8294=(($8293)&65535);
15069       var $8295=(($8289+($8294<<2))|0);
15070       var $8296=$8295;
15071       var $8297=$8296;
15072       var $8298=(($8297)|0);
15073       var $8299=HEAP32[(($8298)>>2)];
15074       var $8300=$ptr7;
15075       var $8301=$8300;
15076       var $8302=(($8301)|0);
15077       HEAP32[(($8302)>>2)]=$8299;
15078       var $8303=$2;
15079       var $8304=(($8303+64)|0);
15080       var $8305=HEAP32[(($8304)>>2)];
15081       var $8306=$st;
15082       var $8307=(($8306+2)|0);
15083       var $8308=$8307;
15084       var $8309=HEAP16[(($8308)>>1)];
15085       var $8310=(($8309)&65535);
15086       var $8311=(($8305+($8310<<2))|0);
15087       var $8312=$8311;
15088       var $8313=$8312;
15089       var $8314=(($8313+4)|0);
15090       var $8315=HEAP32[(($8314)>>2)];
15091       var $8316=$ptr7;
15092       var $8317=$8316;
15093       var $8318=(($8317+4)|0);
15094       HEAP32[(($8318)>>2)]=$8315;
15095       var $8319=$2;
15096       var $8320=(($8319+64)|0);
15097       var $8321=HEAP32[(($8320)>>2)];
15098       var $8322=$st;
15099       var $8323=(($8322+2)|0);
15100       var $8324=$8323;
15101       var $8325=HEAP16[(($8324)>>1)];
15102       var $8326=(($8325)&65535);
15103       var $8327=(($8321+($8326<<2))|0);
15104       var $8328=$8327;
15105       var $8329=$8328;
15106       var $8330=(($8329+8)|0);
15107       var $8331=HEAP32[(($8330)>>2)];
15108       var $8332=$ptr7;
15109       var $8333=$8332;
15110       var $8334=(($8333+8)|0);
15111       HEAP32[(($8334)>>2)]=$8331;
15112       __label__ = 366; break;
15113     case 319:
15114       var $8336=$2;
15115       var $8337=(($8336+64)|0);
15116       var $8338=HEAP32[(($8337)>>2)];
15117       var $8339=$st;
15118       var $8340=(($8339+2)|0);
15119       var $8341=$8340;
15120       var $8342=HEAP16[(($8341)>>1)];
15121       var $8343=(($8342)&65535);
15122       var $8344=(($8338+($8343<<2))|0);
15123       var $8345=$8344;
15124       var $8346=$8345;
15125       var $8347=HEAP32[(($8346)>>2)];
15126       var $8348=$8347 & 2147483647;
15127       var $8349=(($8348)|0)!=0;
15128       var $8350=$8349 ^ 1;
15129       var $8351=(($8350)&1);
15130       var $8352=(($8351)|0);
15131       var $8353=$2;
15132       var $8354=(($8353+64)|0);
15133       var $8355=HEAP32[(($8354)>>2)];
15134       var $8356=$st;
15135       var $8357=(($8356+6)|0);
15136       var $8358=$8357;
15137       var $8359=HEAP16[(($8358)>>1)];
15138       var $8360=(($8359)&65535);
15139       var $8361=(($8355+($8360<<2))|0);
15140       var $8362=$8361;
15141       var $8363=$8362;
15142       HEAPF32[(($8363)>>2)]=$8352;
15143       __label__ = 366; break;
15144     case 320:
15145       var $8365=$2;
15146       var $8366=(($8365+64)|0);
15147       var $8367=HEAP32[(($8366)>>2)];
15148       var $8368=$st;
15149       var $8369=(($8368+2)|0);
15150       var $8370=$8369;
15151       var $8371=HEAP16[(($8370)>>1)];
15152       var $8372=(($8371)&65535);
15153       var $8373=(($8367+($8372<<2))|0);
15154       var $8374=$8373;
15155       var $8375=$8374;
15156       var $8376=(($8375)|0);
15157       var $8377=HEAPF32[(($8376)>>2)];
15158       var $8378=$8377 != 0;
15159       if ($8378) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 321; break; }
15160     case 321:
15161       var $8380=$2;
15162       var $8381=(($8380+64)|0);
15163       var $8382=HEAP32[(($8381)>>2)];
15164       var $8383=$st;
15165       var $8384=(($8383+2)|0);
15166       var $8385=$8384;
15167       var $8386=HEAP16[(($8385)>>1)];
15168       var $8387=(($8386)&65535);
15169       var $8388=(($8382+($8387<<2))|0);
15170       var $8389=$8388;
15171       var $8390=$8389;
15172       var $8391=(($8390+4)|0);
15173       var $8392=HEAPF32[(($8391)>>2)];
15174       var $8393=$8392 != 0;
15175       if ($8393) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 322; break; }
15176     case 322:
15177       var $8395=$2;
15178       var $8396=(($8395+64)|0);
15179       var $8397=HEAP32[(($8396)>>2)];
15180       var $8398=$st;
15181       var $8399=(($8398+2)|0);
15182       var $8400=$8399;
15183       var $8401=HEAP16[(($8400)>>1)];
15184       var $8402=(($8401)&65535);
15185       var $8403=(($8397+($8402<<2))|0);
15186       var $8404=$8403;
15187       var $8405=$8404;
15188       var $8406=(($8405+8)|0);
15189       var $8407=HEAPF32[(($8406)>>2)];
15190       var $8408=$8407 != 0;
15191       var $8409=$8408 ^ 1;
15192       var $8411 = $8409;__label__ = 323; break;
15193     case 323:
15194       var $8411;
15195       var $8412=(($8411)&1);
15196       var $8413=(($8412)|0);
15197       var $8414=$2;
15198       var $8415=(($8414+64)|0);
15199       var $8416=HEAP32[(($8415)>>2)];
15200       var $8417=$st;
15201       var $8418=(($8417+6)|0);
15202       var $8419=$8418;
15203       var $8420=HEAP16[(($8419)>>1)];
15204       var $8421=(($8420)&65535);
15205       var $8422=(($8416+($8421<<2))|0);
15206       var $8423=$8422;
15207       var $8424=$8423;
15208       HEAPF32[(($8424)>>2)]=$8413;
15209       __label__ = 366; break;
15210     case 324:
15211       var $8426=$2;
15212       var $8427=(($8426+64)|0);
15213       var $8428=HEAP32[(($8427)>>2)];
15214       var $8429=$st;
15215       var $8430=(($8429+2)|0);
15216       var $8431=$8430;
15217       var $8432=HEAP16[(($8431)>>1)];
15218       var $8433=(($8432)&65535);
15219       var $8434=(($8428+($8433<<2))|0);
15220       var $8435=$8434;
15221       var $8436=$8435;
15222       var $8437=HEAP32[(($8436)>>2)];
15223       var $8438=(($8437)|0)!=0;
15224       if ($8438) { __label__ = 325; break; } else { var $8458 = 1;__label__ = 326; break; }
15225     case 325:
15226       var $8440=$2;
15227       var $8441=$2;
15228       var $8442=(($8441+64)|0);
15229       var $8443=HEAP32[(($8442)>>2)];
15230       var $8444=$st;
15231       var $8445=(($8444+2)|0);
15232       var $8446=$8445;
15233       var $8447=HEAP16[(($8446)>>1)];
15234       var $8448=(($8447)&65535);
15235       var $8449=(($8443+($8448<<2))|0);
15236       var $8450=$8449;
15237       var $8451=$8450;
15238       var $8452=HEAP32[(($8451)>>2)];
15239       var $8453=_prog_getstring($8440, $8452);
15240       var $8454=HEAP8[($8453)];
15241       var $8455=(($8454 << 24) >> 24)!=0;
15242       var $8456=$8455 ^ 1;
15243       var $8458 = $8456;__label__ = 326; break;
15244     case 326:
15245       var $8458;
15246       var $8459=(($8458)&1);
15247       var $8460=(($8459)|0);
15248       var $8461=$2;
15249       var $8462=(($8461+64)|0);
15250       var $8463=HEAP32[(($8462)>>2)];
15251       var $8464=$st;
15252       var $8465=(($8464+6)|0);
15253       var $8466=$8465;
15254       var $8467=HEAP16[(($8466)>>1)];
15255       var $8468=(($8467)&65535);
15256       var $8469=(($8463+($8468<<2))|0);
15257       var $8470=$8469;
15258       var $8471=$8470;
15259       HEAPF32[(($8471)>>2)]=$8460;
15260       __label__ = 366; break;
15261     case 327:
15262       var $8473=$2;
15263       var $8474=(($8473+64)|0);
15264       var $8475=HEAP32[(($8474)>>2)];
15265       var $8476=$st;
15266       var $8477=(($8476+2)|0);
15267       var $8478=$8477;
15268       var $8479=HEAP16[(($8478)>>1)];
15269       var $8480=(($8479)&65535);
15270       var $8481=(($8475+($8480<<2))|0);
15271       var $8482=$8481;
15272       var $8483=$8482;
15273       var $8484=HEAP32[(($8483)>>2)];
15274       var $8485=(($8484)|0)==0;
15275       var $8486=(($8485)&1);
15276       var $8487=(($8486)|0);
15277       var $8488=$2;
15278       var $8489=(($8488+64)|0);
15279       var $8490=HEAP32[(($8489)>>2)];
15280       var $8491=$st;
15281       var $8492=(($8491+6)|0);
15282       var $8493=$8492;
15283       var $8494=HEAP16[(($8493)>>1)];
15284       var $8495=(($8494)&65535);
15285       var $8496=(($8490+($8495<<2))|0);
15286       var $8497=$8496;
15287       var $8498=$8497;
15288       HEAPF32[(($8498)>>2)]=$8487;
15289       __label__ = 366; break;
15290     case 328:
15291       var $8500=$2;
15292       var $8501=(($8500+64)|0);
15293       var $8502=HEAP32[(($8501)>>2)];
15294       var $8503=$st;
15295       var $8504=(($8503+2)|0);
15296       var $8505=$8504;
15297       var $8506=HEAP16[(($8505)>>1)];
15298       var $8507=(($8506)&65535);
15299       var $8508=(($8502+($8507<<2))|0);
15300       var $8509=$8508;
15301       var $8510=$8509;
15302       var $8511=HEAP32[(($8510)>>2)];
15303       var $8512=(($8511)|0)!=0;
15304       var $8513=$8512 ^ 1;
15305       var $8514=(($8513)&1);
15306       var $8515=(($8514)|0);
15307       var $8516=$2;
15308       var $8517=(($8516+64)|0);
15309       var $8518=HEAP32[(($8517)>>2)];
15310       var $8519=$st;
15311       var $8520=(($8519+6)|0);
15312       var $8521=$8520;
15313       var $8522=HEAP16[(($8521)>>1)];
15314       var $8523=(($8522)&65535);
15315       var $8524=(($8518+($8523<<2))|0);
15316       var $8525=$8524;
15317       var $8526=$8525;
15318       HEAPF32[(($8526)>>2)]=$8515;
15319       __label__ = 366; break;
15320     case 329:
15321       var $8528=$2;
15322       var $8529=(($8528+64)|0);
15323       var $8530=HEAP32[(($8529)>>2)];
15324       var $8531=$st;
15325       var $8532=(($8531+2)|0);
15326       var $8533=$8532;
15327       var $8534=HEAP16[(($8533)>>1)];
15328       var $8535=(($8534)&65535);
15329       var $8536=(($8530+($8535<<2))|0);
15330       var $8537=$8536;
15331       var $8538=$8537;
15332       var $8539=HEAP32[(($8538)>>2)];
15333       var $8540=$8539 & 2147483647;
15334       var $8541=(($8540)|0)!=0;
15335       if ($8541) { __label__ = 330; break; } else { __label__ = 333; break; }
15336     case 330:
15337       var $8543=$st;
15338       var $8544=(($8543+4)|0);
15339       var $8545=$8544;
15340       var $8546=HEAP16[(($8545)>>1)];
15341       var $8547=(($8546 << 16) >> 16);
15342       var $8548=((($8547)-(1))|0);
15343       var $8549=$st;
15344       var $8550=(($8549+($8548<<3))|0);
15345       $st=$8550;
15346       var $8551=$jumpcount;
15347       var $8552=((($8551)+(1))|0);
15348       $jumpcount=$8552;
15349       var $8553=$5;
15350       var $8554=(($8552)|0) >= (($8553)|0);
15351       if ($8554) { __label__ = 331; break; } else { __label__ = 332; break; }
15352     case 331:
15353       var $8556=$2;
15354       var $8557=$2;
15355       var $8558=(($8557)|0);
15356       var $8559=HEAP32[(($8558)>>2)];
15357       var $8560=$jumpcount;
15358       _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));
15359       __label__ = 332; break;
15360     case 332:
15361       __label__ = 333; break;
15362     case 333:
15363       __label__ = 366; break;
15364     case 334:
15365       var $8564=$2;
15366       var $8565=(($8564+64)|0);
15367       var $8566=HEAP32[(($8565)>>2)];
15368       var $8567=$st;
15369       var $8568=(($8567+2)|0);
15370       var $8569=$8568;
15371       var $8570=HEAP16[(($8569)>>1)];
15372       var $8571=(($8570)&65535);
15373       var $8572=(($8566+($8571<<2))|0);
15374       var $8573=$8572;
15375       var $8574=$8573;
15376       var $8575=HEAP32[(($8574)>>2)];
15377       var $8576=$8575 & 2147483647;
15378       var $8577=(($8576)|0)!=0;
15379       if ($8577) { __label__ = 338; break; } else { __label__ = 335; break; }
15380     case 335:
15381       var $8579=$st;
15382       var $8580=(($8579+4)|0);
15383       var $8581=$8580;
15384       var $8582=HEAP16[(($8581)>>1)];
15385       var $8583=(($8582 << 16) >> 16);
15386       var $8584=((($8583)-(1))|0);
15387       var $8585=$st;
15388       var $8586=(($8585+($8584<<3))|0);
15389       $st=$8586;
15390       var $8587=$jumpcount;
15391       var $8588=((($8587)+(1))|0);
15392       $jumpcount=$8588;
15393       var $8589=$5;
15394       var $8590=(($8588)|0) >= (($8589)|0);
15395       if ($8590) { __label__ = 336; break; } else { __label__ = 337; break; }
15396     case 336:
15397       var $8592=$2;
15398       var $8593=$2;
15399       var $8594=(($8593)|0);
15400       var $8595=HEAP32[(($8594)>>2)];
15401       var $8596=$jumpcount;
15402       _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));
15403       __label__ = 337; break;
15404     case 337:
15405       __label__ = 338; break;
15406     case 338:
15407       __label__ = 366; break;
15408     case 339:
15409       var $8600=$st;
15410       var $8601=(($8600)|0);
15411       var $8602=HEAP16[(($8601)>>1)];
15412       var $8603=(($8602)&65535);
15413       var $8604=((($8603)-(51))|0);
15414       var $8605=$2;
15415       var $8606=(($8605+184)|0);
15416       HEAP32[(($8606)>>2)]=$8604;
15417       var $8607=$2;
15418       var $8608=(($8607+64)|0);
15419       var $8609=HEAP32[(($8608)>>2)];
15420       var $8610=$st;
15421       var $8611=(($8610+2)|0);
15422       var $8612=$8611;
15423       var $8613=HEAP16[(($8612)>>1)];
15424       var $8614=(($8613)&65535);
15425       var $8615=(($8609+($8614<<2))|0);
15426       var $8616=$8615;
15427       var $8617=$8616;
15428       var $8618=HEAP32[(($8617)>>2)];
15429       var $8619=(($8618)|0)!=0;
15430       if ($8619) { __label__ = 341; break; } else { __label__ = 340; break; }
15431     case 340:
15432       var $8621=$2;
15433       var $8622=$2;
15434       var $8623=(($8622)|0);
15435       var $8624=HEAP32[(($8623)>>2)];
15436       _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));
15437       __label__ = 341; break;
15438     case 341:
15439       var $8626=$2;
15440       var $8627=(($8626+64)|0);
15441       var $8628=HEAP32[(($8627)>>2)];
15442       var $8629=$st;
15443       var $8630=(($8629+2)|0);
15444       var $8631=$8630;
15445       var $8632=HEAP16[(($8631)>>1)];
15446       var $8633=(($8632)&65535);
15447       var $8634=(($8628+($8633<<2))|0);
15448       var $8635=$8634;
15449       var $8636=$8635;
15450       var $8637=HEAP32[(($8636)>>2)];
15451       var $8638=(($8637)|0)!=0;
15452       if ($8638) { __label__ = 342; break; } else { __label__ = 343; break; }
15453     case 342:
15454       var $8640=$2;
15455       var $8641=(($8640+64)|0);
15456       var $8642=HEAP32[(($8641)>>2)];
15457       var $8643=$st;
15458       var $8644=(($8643+2)|0);
15459       var $8645=$8644;
15460       var $8646=HEAP16[(($8645)>>1)];
15461       var $8647=(($8646)&65535);
15462       var $8648=(($8642+($8647<<2))|0);
15463       var $8649=$8648;
15464       var $8650=$8649;
15465       var $8651=HEAP32[(($8650)>>2)];
15466       var $8652=$2;
15467       var $8653=(($8652+44)|0);
15468       var $8654=HEAP32[(($8653)>>2)];
15469       var $8655=(($8651)>>>0) >= (($8654)>>>0);
15470       if ($8655) { __label__ = 343; break; } else { __label__ = 344; break; }
15471     case 343:
15472       var $8657=$2;
15473       var $8658=$2;
15474       var $8659=(($8658)|0);
15475       var $8660=HEAP32[(($8659)>>2)];
15476       _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));
15477       __label__ = 488; break;
15478     case 344:
15479       var $8662=$2;
15480       var $8663=(($8662+64)|0);
15481       var $8664=HEAP32[(($8663)>>2)];
15482       var $8665=$st;
15483       var $8666=(($8665+2)|0);
15484       var $8667=$8666;
15485       var $8668=HEAP16[(($8667)>>1)];
15486       var $8669=(($8668)&65535);
15487       var $8670=(($8664+($8669<<2))|0);
15488       var $8671=$8670;
15489       var $8672=$8671;
15490       var $8673=HEAP32[(($8672)>>2)];
15491       var $8674=$2;
15492       var $8675=(($8674+40)|0);
15493       var $8676=HEAP32[(($8675)>>2)];
15494       var $8677=(($8676+($8673)*(36))|0);
15495       $newf5=$8677;
15496       var $8678=$newf5;
15497       var $8679=(($8678+12)|0);
15498       var $8680=HEAP32[(($8679)>>2)];
15499       var $8681=((($8680)+(1))|0);
15500       HEAP32[(($8679)>>2)]=$8681;
15501       var $8682=$st;
15502       var $8683=$2;
15503       var $8684=(($8683+4)|0);
15504       var $8685=HEAP32[(($8684)>>2)];
15505       var $8686=$8682;
15506       var $8687=$8685;
15507       var $8688=((($8686)-($8687))|0);
15508       var $8689=((((($8688)|0))/(8))&-1);
15509       var $8690=((($8689)+(1))|0);
15510       var $8691=$2;
15511       var $8692=(($8691+176)|0);
15512       HEAP32[(($8692)>>2)]=$8690;
15513       var $8693=$newf5;
15514       var $8694=(($8693)|0);
15515       var $8695=HEAP32[(($8694)>>2)];
15516       var $8696=(($8695)|0) < 0;
15517       if ($8696) { __label__ = 345; break; } else { __label__ = 350; break; }
15518     case 345:
15519       var $8698=$newf5;
15520       var $8699=(($8698)|0);
15521       var $8700=HEAP32[(($8699)>>2)];
15522       var $8701=(((-$8700))|0);
15523       $builtinnumber8=$8701;
15524       var $8702=$builtinnumber8;
15525       var $8703=$2;
15526       var $8704=(($8703+132)|0);
15527       var $8705=HEAP32[(($8704)>>2)];
15528       var $8706=(($8702)>>>0) < (($8705)>>>0);
15529       if ($8706) { __label__ = 346; break; } else { __label__ = 348; break; }
15530     case 346:
15531       var $8708=$builtinnumber8;
15532       var $8709=$2;
15533       var $8710=(($8709+128)|0);
15534       var $8711=HEAP32[(($8710)>>2)];
15535       var $8712=(($8711+($8708<<2))|0);
15536       var $8713=HEAP32[(($8712)>>2)];
15537       var $8714=(($8713)|0)!=0;
15538       if ($8714) { __label__ = 347; break; } else { __label__ = 348; break; }
15539     case 347:
15540       var $8716=$builtinnumber8;
15541       var $8717=$2;
15542       var $8718=(($8717+128)|0);
15543       var $8719=HEAP32[(($8718)>>2)];
15544       var $8720=(($8719+($8716<<2))|0);
15545       var $8721=HEAP32[(($8720)>>2)];
15546       var $8722=$2;
15547       var $8723=FUNCTION_TABLE[$8721]($8722);
15548       __label__ = 349; break;
15549     case 348:
15550       var $8725=$2;
15551       var $8726=$builtinnumber8;
15552       var $8727=$2;
15553       var $8728=(($8727)|0);
15554       var $8729=HEAP32[(($8728)>>2)];
15555       _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));
15556       __label__ = 349; break;
15557     case 349:
15558       __label__ = 351; break;
15559     case 350:
15560       var $8732=$2;
15561       var $8733=(($8732+4)|0);
15562       var $8734=HEAP32[(($8733)>>2)];
15563       var $8735=$2;
15564       var $8736=$newf5;
15565       var $8737=_prog_enterfunction($8735, $8736);
15566       var $8738=(($8734+($8737<<3))|0);
15567       var $8739=((($8738)-(8))|0);
15568       $st=$8739;
15569       __label__ = 351; break;
15570     case 351:
15571       var $8741=$2;
15572       var $8742=(($8741+112)|0);
15573       var $8743=HEAP32[(($8742)>>2)];
15574       var $8744=(($8743)|0)!=0;
15575       if ($8744) { __label__ = 352; break; } else { __label__ = 353; break; }
15576     case 352:
15577       __label__ = 488; break;
15578     case 353:
15579       __label__ = 366; break;
15580     case 354:
15581       var $8748=$2;
15582       var $8749=$2;
15583       var $8750=(($8749)|0);
15584       var $8751=HEAP32[(($8750)>>2)];
15585       _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));
15586       __label__ = 366; break;
15587     case 355:
15588       var $8753=$st;
15589       var $8754=(($8753+2)|0);
15590       var $8755=$8754;
15591       var $8756=HEAP16[(($8755)>>1)];
15592       var $8757=(($8756 << 16) >> 16);
15593       var $8758=((($8757)-(1))|0);
15594       var $8759=$st;
15595       var $8760=(($8759+($8758<<3))|0);
15596       $st=$8760;
15597       var $8761=$jumpcount;
15598       var $8762=((($8761)+(1))|0);
15599       $jumpcount=$8762;
15600       var $8763=(($8762)|0)==10000000;
15601       if ($8763) { __label__ = 356; break; } else { __label__ = 357; break; }
15602     case 356:
15603       var $8765=$2;
15604       var $8766=$2;
15605       var $8767=(($8766)|0);
15606       var $8768=HEAP32[(($8767)>>2)];
15607       var $8769=$jumpcount;
15608       _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));
15609       __label__ = 357; break;
15610     case 357:
15611       __label__ = 366; break;
15612     case 358:
15613       var $8772=$2;
15614       var $8773=(($8772+64)|0);
15615       var $8774=HEAP32[(($8773)>>2)];
15616       var $8775=$st;
15617       var $8776=(($8775+2)|0);
15618       var $8777=$8776;
15619       var $8778=HEAP16[(($8777)>>1)];
15620       var $8779=(($8778)&65535);
15621       var $8780=(($8774+($8779<<2))|0);
15622       var $8781=$8780;
15623       var $8782=$8781;
15624       var $8783=HEAP32[(($8782)>>2)];
15625       var $8784=$8783 & 2147483647;
15626       var $8785=(($8784)|0)!=0;
15627       if ($8785) { __label__ = 359; break; } else { var $8802 = 0;__label__ = 360; break; }
15628     case 359:
15629       var $8787=$2;
15630       var $8788=(($8787+64)|0);
15631       var $8789=HEAP32[(($8788)>>2)];
15632       var $8790=$st;
15633       var $8791=(($8790+4)|0);
15634       var $8792=$8791;
15635       var $8793=HEAP16[(($8792)>>1)];
15636       var $8794=(($8793)&65535);
15637       var $8795=(($8789+($8794<<2))|0);
15638       var $8796=$8795;
15639       var $8797=$8796;
15640       var $8798=HEAP32[(($8797)>>2)];
15641       var $8799=$8798 & 2147483647;
15642       var $8800=(($8799)|0)!=0;
15643       var $8802 = $8800;__label__ = 360; break;
15644     case 360:
15645       var $8802;
15646       var $8803=(($8802)&1);
15647       var $8804=(($8803)|0);
15648       var $8805=$2;
15649       var $8806=(($8805+64)|0);
15650       var $8807=HEAP32[(($8806)>>2)];
15651       var $8808=$st;
15652       var $8809=(($8808+6)|0);
15653       var $8810=$8809;
15654       var $8811=HEAP16[(($8810)>>1)];
15655       var $8812=(($8811)&65535);
15656       var $8813=(($8807+($8812<<2))|0);
15657       var $8814=$8813;
15658       var $8815=$8814;
15659       HEAPF32[(($8815)>>2)]=$8804;
15660       __label__ = 366; break;
15661     case 361:
15662       var $8817=$2;
15663       var $8818=(($8817+64)|0);
15664       var $8819=HEAP32[(($8818)>>2)];
15665       var $8820=$st;
15666       var $8821=(($8820+2)|0);
15667       var $8822=$8821;
15668       var $8823=HEAP16[(($8822)>>1)];
15669       var $8824=(($8823)&65535);
15670       var $8825=(($8819+($8824<<2))|0);
15671       var $8826=$8825;
15672       var $8827=$8826;
15673       var $8828=HEAP32[(($8827)>>2)];
15674       var $8829=$8828 & 2147483647;
15675       var $8830=(($8829)|0)!=0;
15676       if ($8830) { var $8847 = 1;__label__ = 363; break; } else { __label__ = 362; break; }
15677     case 362:
15678       var $8832=$2;
15679       var $8833=(($8832+64)|0);
15680       var $8834=HEAP32[(($8833)>>2)];
15681       var $8835=$st;
15682       var $8836=(($8835+4)|0);
15683       var $8837=$8836;
15684       var $8838=HEAP16[(($8837)>>1)];
15685       var $8839=(($8838)&65535);
15686       var $8840=(($8834+($8839<<2))|0);
15687       var $8841=$8840;
15688       var $8842=$8841;
15689       var $8843=HEAP32[(($8842)>>2)];
15690       var $8844=$8843 & 2147483647;
15691       var $8845=(($8844)|0)!=0;
15692       var $8847 = $8845;__label__ = 363; break;
15693     case 363:
15694       var $8847;
15695       var $8848=(($8847)&1);
15696       var $8849=(($8848)|0);
15697       var $8850=$2;
15698       var $8851=(($8850+64)|0);
15699       var $8852=HEAP32[(($8851)>>2)];
15700       var $8853=$st;
15701       var $8854=(($8853+6)|0);
15702       var $8855=$8854;
15703       var $8856=HEAP16[(($8855)>>1)];
15704       var $8857=(($8856)&65535);
15705       var $8858=(($8852+($8857<<2))|0);
15706       var $8859=$8858;
15707       var $8860=$8859;
15708       HEAPF32[(($8860)>>2)]=$8849;
15709       __label__ = 366; break;
15710     case 364:
15711       var $8862=$2;
15712       var $8863=(($8862+64)|0);
15713       var $8864=HEAP32[(($8863)>>2)];
15714       var $8865=$st;
15715       var $8866=(($8865+2)|0);
15716       var $8867=$8866;
15717       var $8868=HEAP16[(($8867)>>1)];
15718       var $8869=(($8868)&65535);
15719       var $8870=(($8864+($8869<<2))|0);
15720       var $8871=$8870;
15721       var $8872=$8871;
15722       var $8873=HEAPF32[(($8872)>>2)];
15723       var $8874=(($8873)&-1);
15724       var $8875=$2;
15725       var $8876=(($8875+64)|0);
15726       var $8877=HEAP32[(($8876)>>2)];
15727       var $8878=$st;
15728       var $8879=(($8878+4)|0);
15729       var $8880=$8879;
15730       var $8881=HEAP16[(($8880)>>1)];
15731       var $8882=(($8881)&65535);
15732       var $8883=(($8877+($8882<<2))|0);
15733       var $8884=$8883;
15734       var $8885=$8884;
15735       var $8886=HEAPF32[(($8885)>>2)];
15736       var $8887=(($8886)&-1);
15737       var $8888=$8874 & $8887;
15738       var $8889=(($8888)|0);
15739       var $8890=$2;
15740       var $8891=(($8890+64)|0);
15741       var $8892=HEAP32[(($8891)>>2)];
15742       var $8893=$st;
15743       var $8894=(($8893+6)|0);
15744       var $8895=$8894;
15745       var $8896=HEAP16[(($8895)>>1)];
15746       var $8897=(($8896)&65535);
15747       var $8898=(($8892+($8897<<2))|0);
15748       var $8899=$8898;
15749       var $8900=$8899;
15750       HEAPF32[(($8900)>>2)]=$8889;
15751       __label__ = 366; break;
15752     case 365:
15753       var $8902=$2;
15754       var $8903=(($8902+64)|0);
15755       var $8904=HEAP32[(($8903)>>2)];
15756       var $8905=$st;
15757       var $8906=(($8905+2)|0);
15758       var $8907=$8906;
15759       var $8908=HEAP16[(($8907)>>1)];
15760       var $8909=(($8908)&65535);
15761       var $8910=(($8904+($8909<<2))|0);
15762       var $8911=$8910;
15763       var $8912=$8911;
15764       var $8913=HEAPF32[(($8912)>>2)];
15765       var $8914=(($8913)&-1);
15766       var $8915=$2;
15767       var $8916=(($8915+64)|0);
15768       var $8917=HEAP32[(($8916)>>2)];
15769       var $8918=$st;
15770       var $8919=(($8918+4)|0);
15771       var $8920=$8919;
15772       var $8921=HEAP16[(($8920)>>1)];
15773       var $8922=(($8921)&65535);
15774       var $8923=(($8917+($8922<<2))|0);
15775       var $8924=$8923;
15776       var $8925=$8924;
15777       var $8926=HEAPF32[(($8925)>>2)];
15778       var $8927=(($8926)&-1);
15779       var $8928=$8914 | $8927;
15780       var $8929=(($8928)|0);
15781       var $8930=$2;
15782       var $8931=(($8930+64)|0);
15783       var $8932=HEAP32[(($8931)>>2)];
15784       var $8933=$st;
15785       var $8934=(($8933+6)|0);
15786       var $8935=$8934;
15787       var $8936=HEAP16[(($8935)>>1)];
15788       var $8937=(($8936)&65535);
15789       var $8938=(($8932+($8937<<2))|0);
15790       var $8939=$8938;
15791       var $8940=$8939;
15792       HEAPF32[(($8940)>>2)]=$8929;
15793       __label__ = 366; break;
15794     case 366:
15795       __label__ = 247; break;
15796     case 367:
15797       __label__ = 368; break;
15798     case 368:
15799       var $8944=$st;
15800       var $8945=(($8944+8)|0);
15801       $st=$8945;
15802       var $8946=$st;
15803       var $8947=$2;
15804       var $8948=(($8947+4)|0);
15805       var $8949=HEAP32[(($8948)>>2)];
15806       var $8950=$8946;
15807       var $8951=$8949;
15808       var $8952=((($8950)-($8951))|0);
15809       var $8953=((((($8952)|0))/(8))&-1);
15810       var $8954=$2;
15811       var $8955=(($8954+116)|0);
15812       var $8956=HEAP32[(($8955)>>2)];
15813       var $8957=(($8956+($8953<<2))|0);
15814       var $8958=HEAP32[(($8957)>>2)];
15815       var $8959=((($8958)+(1))|0);
15816       HEAP32[(($8957)>>2)]=$8959;
15817       var $8960=$2;
15818       var $8961=$st;
15819       _prog_print_statement($8960, $8961);
15820       var $8962=$st;
15821       var $8963=(($8962)|0);
15822       var $8964=HEAP16[(($8963)>>1)];
15823       var $8965=(($8964)&65535);
15824       if ((($8965)|0) == 0 || (($8965)|0) == 43) {
15825         __label__ = 370; break;
15826       }
15827       else if ((($8965)|0) == 1) {
15828         __label__ = 373; break;
15829       }
15830       else if ((($8965)|0) == 2) {
15831         __label__ = 374; break;
15832       }
15833       else if ((($8965)|0) == 3) {
15834         __label__ = 375; break;
15835       }
15836       else if ((($8965)|0) == 4) {
15837         __label__ = 376; break;
15838       }
15839       else if ((($8965)|0) == 5) {
15840         __label__ = 377; break;
15841       }
15842       else if ((($8965)|0) == 6) {
15843         __label__ = 381; break;
15844       }
15845       else if ((($8965)|0) == 7) {
15846         __label__ = 382; break;
15847       }
15848       else if ((($8965)|0) == 8) {
15849         __label__ = 383; break;
15850       }
15851       else if ((($8965)|0) == 9) {
15852         __label__ = 384; break;
15853       }
15854       else if ((($8965)|0) == 10) {
15855         __label__ = 385; break;
15856       }
15857       else if ((($8965)|0) == 11) {
15858         __label__ = 386; break;
15859       }
15860       else if ((($8965)|0) == 12) {
15861         __label__ = 390; break;
15862       }
15863       else if ((($8965)|0) == 13) {
15864         __label__ = 391; break;
15865       }
15866       else if ((($8965)|0) == 14) {
15867         __label__ = 392; break;
15868       }
15869       else if ((($8965)|0) == 15) {
15870         __label__ = 393; break;
15871       }
15872       else if ((($8965)|0) == 16) {
15873         __label__ = 394; break;
15874       }
15875       else if ((($8965)|0) == 17) {
15876         __label__ = 398; break;
15877       }
15878       else if ((($8965)|0) == 18) {
15879         __label__ = 399; break;
15880       }
15881       else if ((($8965)|0) == 19) {
15882         __label__ = 400; break;
15883       }
15884       else if ((($8965)|0) == 20) {
15885         __label__ = 401; break;
15886       }
15887       else if ((($8965)|0) == 21) {
15888         __label__ = 402; break;
15889       }
15890       else if ((($8965)|0) == 22) {
15891         __label__ = 403; break;
15892       }
15893       else if ((($8965)|0) == 23) {
15894         __label__ = 404; break;
15895       }
15896       else if ((($8965)|0) == 24 || (($8965)|0) == 26 || (($8965)|0) == 28 || (($8965)|0) == 27 || (($8965)|0) == 29) {
15897         __label__ = 405; break;
15898       }
15899       else if ((($8965)|0) == 25) {
15900         __label__ = 411; break;
15901       }
15902       else if ((($8965)|0) == 30) {
15903         __label__ = 418; break;
15904       }
15905       else if ((($8965)|0) == 31 || (($8965)|0) == 33 || (($8965)|0) == 34 || (($8965)|0) == 35 || (($8965)|0) == 36) {
15906         __label__ = 424; break;
15907       }
15908       else if ((($8965)|0) == 32) {
15909         __label__ = 425; break;
15910       }
15911       else if ((($8965)|0) == 37 || (($8965)|0) == 39 || (($8965)|0) == 40 || (($8965)|0) == 41 || (($8965)|0) == 42) {
15912         __label__ = 426; break;
15913       }
15914       else if ((($8965)|0) == 38) {
15915         __label__ = 433; break;
15916       }
15917       else if ((($8965)|0) == 44) {
15918         __label__ = 440; break;
15919       }
15920       else if ((($8965)|0) == 45) {
15921         __label__ = 441; break;
15922       }
15923       else if ((($8965)|0) == 46) {
15924         __label__ = 445; break;
15925       }
15926       else if ((($8965)|0) == 47) {
15927         __label__ = 448; break;
15928       }
15929       else if ((($8965)|0) == 48) {
15930         __label__ = 449; break;
15931       }
15932       else if ((($8965)|0) == 49) {
15933         __label__ = 450; break;
15934       }
15935       else if ((($8965)|0) == 50) {
15936         __label__ = 455; break;
15937       }
15938       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) {
15939         __label__ = 460; break;
15940       }
15941       else if ((($8965)|0) == 60) {
15942         __label__ = 475; break;
15943       }
15944       else if ((($8965)|0) == 61) {
15945         __label__ = 476; break;
15946       }
15947       else if ((($8965)|0) == 62) {
15948         __label__ = 479; break;
15949       }
15950       else if ((($8965)|0) == 63) {
15951         __label__ = 482; break;
15952       }
15953       else if ((($8965)|0) == 64) {
15954         __label__ = 485; break;
15955       }
15956       else if ((($8965)|0) == 65) {
15957         __label__ = 486; break;
15958       }
15959       else {
15960       __label__ = 369; break;
15961       }
15962
15963     case 369:
15964       var $8967=$2;
15965       var $8968=$2;
15966       var $8969=(($8968)|0);
15967       var $8970=HEAP32[(($8969)>>2)];
15968       _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));
15969       __label__ = 488; break;
15970     case 370:
15971       var $8972=$2;
15972       var $8973=(($8972+64)|0);
15973       var $8974=HEAP32[(($8973)>>2)];
15974       var $8975=$st;
15975       var $8976=(($8975+2)|0);
15976       var $8977=$8976;
15977       var $8978=HEAP16[(($8977)>>1)];
15978       var $8979=(($8978)&65535);
15979       var $8980=(($8974+($8979<<2))|0);
15980       var $8981=$8980;
15981       var $8982=$8981;
15982       var $8983=(($8982)|0);
15983       var $8984=HEAP32[(($8983)>>2)];
15984       var $8985=$2;
15985       var $8986=(($8985+64)|0);
15986       var $8987=HEAP32[(($8986)>>2)];
15987       var $8988=(($8987+4)|0);
15988       var $8989=$8988;
15989       var $8990=$8989;
15990       var $8991=(($8990)|0);
15991       HEAP32[(($8991)>>2)]=$8984;
15992       var $8992=$2;
15993       var $8993=(($8992+64)|0);
15994       var $8994=HEAP32[(($8993)>>2)];
15995       var $8995=$st;
15996       var $8996=(($8995+2)|0);
15997       var $8997=$8996;
15998       var $8998=HEAP16[(($8997)>>1)];
15999       var $8999=(($8998)&65535);
16000       var $9000=(($8994+($8999<<2))|0);
16001       var $9001=$9000;
16002       var $9002=$9001;
16003       var $9003=(($9002+4)|0);
16004       var $9004=HEAP32[(($9003)>>2)];
16005       var $9005=$2;
16006       var $9006=(($9005+64)|0);
16007       var $9007=HEAP32[(($9006)>>2)];
16008       var $9008=(($9007+4)|0);
16009       var $9009=$9008;
16010       var $9010=$9009;
16011       var $9011=(($9010+4)|0);
16012       HEAP32[(($9011)>>2)]=$9004;
16013       var $9012=$2;
16014       var $9013=(($9012+64)|0);
16015       var $9014=HEAP32[(($9013)>>2)];
16016       var $9015=$st;
16017       var $9016=(($9015+2)|0);
16018       var $9017=$9016;
16019       var $9018=HEAP16[(($9017)>>1)];
16020       var $9019=(($9018)&65535);
16021       var $9020=(($9014+($9019<<2))|0);
16022       var $9021=$9020;
16023       var $9022=$9021;
16024       var $9023=(($9022+8)|0);
16025       var $9024=HEAP32[(($9023)>>2)];
16026       var $9025=$2;
16027       var $9026=(($9025+64)|0);
16028       var $9027=HEAP32[(($9026)>>2)];
16029       var $9028=(($9027+4)|0);
16030       var $9029=$9028;
16031       var $9030=$9029;
16032       var $9031=(($9030+8)|0);
16033       HEAP32[(($9031)>>2)]=$9024;
16034       var $9032=$2;
16035       var $9033=(($9032+4)|0);
16036       var $9034=HEAP32[(($9033)>>2)];
16037       var $9035=$2;
16038       var $9036=_prog_leavefunction($9035);
16039       var $9037=(($9034+($9036<<3))|0);
16040       $st=$9037;
16041       var $9038=$2;
16042       var $9039=(($9038+168)|0);
16043       var $9040=HEAP32[(($9039)>>2)];
16044       var $9041=(($9040)|0)!=0;
16045       if ($9041) { __label__ = 372; break; } else { __label__ = 371; break; }
16046     case 371:
16047       __label__ = 488; break;
16048     case 372:
16049       __label__ = 487; break;
16050     case 373:
16051       var $9045=$2;
16052       var $9046=(($9045+64)|0);
16053       var $9047=HEAP32[(($9046)>>2)];
16054       var $9048=$st;
16055       var $9049=(($9048+2)|0);
16056       var $9050=$9049;
16057       var $9051=HEAP16[(($9050)>>1)];
16058       var $9052=(($9051)&65535);
16059       var $9053=(($9047+($9052<<2))|0);
16060       var $9054=$9053;
16061       var $9055=$9054;
16062       var $9056=HEAPF32[(($9055)>>2)];
16063       var $9057=$2;
16064       var $9058=(($9057+64)|0);
16065       var $9059=HEAP32[(($9058)>>2)];
16066       var $9060=$st;
16067       var $9061=(($9060+4)|0);
16068       var $9062=$9061;
16069       var $9063=HEAP16[(($9062)>>1)];
16070       var $9064=(($9063)&65535);
16071       var $9065=(($9059+($9064<<2))|0);
16072       var $9066=$9065;
16073       var $9067=$9066;
16074       var $9068=HEAPF32[(($9067)>>2)];
16075       var $9069=($9056)*($9068);
16076       var $9070=$2;
16077       var $9071=(($9070+64)|0);
16078       var $9072=HEAP32[(($9071)>>2)];
16079       var $9073=$st;
16080       var $9074=(($9073+6)|0);
16081       var $9075=$9074;
16082       var $9076=HEAP16[(($9075)>>1)];
16083       var $9077=(($9076)&65535);
16084       var $9078=(($9072+($9077<<2))|0);
16085       var $9079=$9078;
16086       var $9080=$9079;
16087       HEAPF32[(($9080)>>2)]=$9069;
16088       __label__ = 487; break;
16089     case 374:
16090       var $9082=$2;
16091       var $9083=(($9082+64)|0);
16092       var $9084=HEAP32[(($9083)>>2)];
16093       var $9085=$st;
16094       var $9086=(($9085+2)|0);
16095       var $9087=$9086;
16096       var $9088=HEAP16[(($9087)>>1)];
16097       var $9089=(($9088)&65535);
16098       var $9090=(($9084+($9089<<2))|0);
16099       var $9091=$9090;
16100       var $9092=$9091;
16101       var $9093=(($9092)|0);
16102       var $9094=HEAPF32[(($9093)>>2)];
16103       var $9095=$2;
16104       var $9096=(($9095+64)|0);
16105       var $9097=HEAP32[(($9096)>>2)];
16106       var $9098=$st;
16107       var $9099=(($9098+4)|0);
16108       var $9100=$9099;
16109       var $9101=HEAP16[(($9100)>>1)];
16110       var $9102=(($9101)&65535);
16111       var $9103=(($9097+($9102<<2))|0);
16112       var $9104=$9103;
16113       var $9105=$9104;
16114       var $9106=(($9105)|0);
16115       var $9107=HEAPF32[(($9106)>>2)];
16116       var $9108=($9094)*($9107);
16117       var $9109=$2;
16118       var $9110=(($9109+64)|0);
16119       var $9111=HEAP32[(($9110)>>2)];
16120       var $9112=$st;
16121       var $9113=(($9112+2)|0);
16122       var $9114=$9113;
16123       var $9115=HEAP16[(($9114)>>1)];
16124       var $9116=(($9115)&65535);
16125       var $9117=(($9111+($9116<<2))|0);
16126       var $9118=$9117;
16127       var $9119=$9118;
16128       var $9120=(($9119+4)|0);
16129       var $9121=HEAPF32[(($9120)>>2)];
16130       var $9122=$2;
16131       var $9123=(($9122+64)|0);
16132       var $9124=HEAP32[(($9123)>>2)];
16133       var $9125=$st;
16134       var $9126=(($9125+4)|0);
16135       var $9127=$9126;
16136       var $9128=HEAP16[(($9127)>>1)];
16137       var $9129=(($9128)&65535);
16138       var $9130=(($9124+($9129<<2))|0);
16139       var $9131=$9130;
16140       var $9132=$9131;
16141       var $9133=(($9132+4)|0);
16142       var $9134=HEAPF32[(($9133)>>2)];
16143       var $9135=($9121)*($9134);
16144       var $9136=($9108)+($9135);
16145       var $9137=$2;
16146       var $9138=(($9137+64)|0);
16147       var $9139=HEAP32[(($9138)>>2)];
16148       var $9140=$st;
16149       var $9141=(($9140+2)|0);
16150       var $9142=$9141;
16151       var $9143=HEAP16[(($9142)>>1)];
16152       var $9144=(($9143)&65535);
16153       var $9145=(($9139+($9144<<2))|0);
16154       var $9146=$9145;
16155       var $9147=$9146;
16156       var $9148=(($9147+8)|0);
16157       var $9149=HEAPF32[(($9148)>>2)];
16158       var $9150=$2;
16159       var $9151=(($9150+64)|0);
16160       var $9152=HEAP32[(($9151)>>2)];
16161       var $9153=$st;
16162       var $9154=(($9153+4)|0);
16163       var $9155=$9154;
16164       var $9156=HEAP16[(($9155)>>1)];
16165       var $9157=(($9156)&65535);
16166       var $9158=(($9152+($9157<<2))|0);
16167       var $9159=$9158;
16168       var $9160=$9159;
16169       var $9161=(($9160+8)|0);
16170       var $9162=HEAPF32[(($9161)>>2)];
16171       var $9163=($9149)*($9162);
16172       var $9164=($9136)+($9163);
16173       var $9165=$2;
16174       var $9166=(($9165+64)|0);
16175       var $9167=HEAP32[(($9166)>>2)];
16176       var $9168=$st;
16177       var $9169=(($9168+6)|0);
16178       var $9170=$9169;
16179       var $9171=HEAP16[(($9170)>>1)];
16180       var $9172=(($9171)&65535);
16181       var $9173=(($9167+($9172<<2))|0);
16182       var $9174=$9173;
16183       var $9175=$9174;
16184       HEAPF32[(($9175)>>2)]=$9164;
16185       __label__ = 487; break;
16186     case 375:
16187       var $9177=$2;
16188       var $9178=(($9177+64)|0);
16189       var $9179=HEAP32[(($9178)>>2)];
16190       var $9180=$st;
16191       var $9181=(($9180+2)|0);
16192       var $9182=$9181;
16193       var $9183=HEAP16[(($9182)>>1)];
16194       var $9184=(($9183)&65535);
16195       var $9185=(($9179+($9184<<2))|0);
16196       var $9186=$9185;
16197       var $9187=$9186;
16198       var $9188=HEAPF32[(($9187)>>2)];
16199       var $9189=$2;
16200       var $9190=(($9189+64)|0);
16201       var $9191=HEAP32[(($9190)>>2)];
16202       var $9192=$st;
16203       var $9193=(($9192+4)|0);
16204       var $9194=$9193;
16205       var $9195=HEAP16[(($9194)>>1)];
16206       var $9196=(($9195)&65535);
16207       var $9197=(($9191+($9196<<2))|0);
16208       var $9198=$9197;
16209       var $9199=$9198;
16210       var $9200=(($9199)|0);
16211       var $9201=HEAPF32[(($9200)>>2)];
16212       var $9202=($9188)*($9201);
16213       var $9203=$2;
16214       var $9204=(($9203+64)|0);
16215       var $9205=HEAP32[(($9204)>>2)];
16216       var $9206=$st;
16217       var $9207=(($9206+6)|0);
16218       var $9208=$9207;
16219       var $9209=HEAP16[(($9208)>>1)];
16220       var $9210=(($9209)&65535);
16221       var $9211=(($9205+($9210<<2))|0);
16222       var $9212=$9211;
16223       var $9213=$9212;
16224       var $9214=(($9213)|0);
16225       HEAPF32[(($9214)>>2)]=$9202;
16226       var $9215=$2;
16227       var $9216=(($9215+64)|0);
16228       var $9217=HEAP32[(($9216)>>2)];
16229       var $9218=$st;
16230       var $9219=(($9218+2)|0);
16231       var $9220=$9219;
16232       var $9221=HEAP16[(($9220)>>1)];
16233       var $9222=(($9221)&65535);
16234       var $9223=(($9217+($9222<<2))|0);
16235       var $9224=$9223;
16236       var $9225=$9224;
16237       var $9226=HEAPF32[(($9225)>>2)];
16238       var $9227=$2;
16239       var $9228=(($9227+64)|0);
16240       var $9229=HEAP32[(($9228)>>2)];
16241       var $9230=$st;
16242       var $9231=(($9230+4)|0);
16243       var $9232=$9231;
16244       var $9233=HEAP16[(($9232)>>1)];
16245       var $9234=(($9233)&65535);
16246       var $9235=(($9229+($9234<<2))|0);
16247       var $9236=$9235;
16248       var $9237=$9236;
16249       var $9238=(($9237+4)|0);
16250       var $9239=HEAPF32[(($9238)>>2)];
16251       var $9240=($9226)*($9239);
16252       var $9241=$2;
16253       var $9242=(($9241+64)|0);
16254       var $9243=HEAP32[(($9242)>>2)];
16255       var $9244=$st;
16256       var $9245=(($9244+6)|0);
16257       var $9246=$9245;
16258       var $9247=HEAP16[(($9246)>>1)];
16259       var $9248=(($9247)&65535);
16260       var $9249=(($9243+($9248<<2))|0);
16261       var $9250=$9249;
16262       var $9251=$9250;
16263       var $9252=(($9251+4)|0);
16264       HEAPF32[(($9252)>>2)]=$9240;
16265       var $9253=$2;
16266       var $9254=(($9253+64)|0);
16267       var $9255=HEAP32[(($9254)>>2)];
16268       var $9256=$st;
16269       var $9257=(($9256+2)|0);
16270       var $9258=$9257;
16271       var $9259=HEAP16[(($9258)>>1)];
16272       var $9260=(($9259)&65535);
16273       var $9261=(($9255+($9260<<2))|0);
16274       var $9262=$9261;
16275       var $9263=$9262;
16276       var $9264=HEAPF32[(($9263)>>2)];
16277       var $9265=$2;
16278       var $9266=(($9265+64)|0);
16279       var $9267=HEAP32[(($9266)>>2)];
16280       var $9268=$st;
16281       var $9269=(($9268+4)|0);
16282       var $9270=$9269;
16283       var $9271=HEAP16[(($9270)>>1)];
16284       var $9272=(($9271)&65535);
16285       var $9273=(($9267+($9272<<2))|0);
16286       var $9274=$9273;
16287       var $9275=$9274;
16288       var $9276=(($9275+8)|0);
16289       var $9277=HEAPF32[(($9276)>>2)];
16290       var $9278=($9264)*($9277);
16291       var $9279=$2;
16292       var $9280=(($9279+64)|0);
16293       var $9281=HEAP32[(($9280)>>2)];
16294       var $9282=$st;
16295       var $9283=(($9282+6)|0);
16296       var $9284=$9283;
16297       var $9285=HEAP16[(($9284)>>1)];
16298       var $9286=(($9285)&65535);
16299       var $9287=(($9281+($9286<<2))|0);
16300       var $9288=$9287;
16301       var $9289=$9288;
16302       var $9290=(($9289+8)|0);
16303       HEAPF32[(($9290)>>2)]=$9278;
16304       __label__ = 487; break;
16305     case 376:
16306       var $9292=$2;
16307       var $9293=(($9292+64)|0);
16308       var $9294=HEAP32[(($9293)>>2)];
16309       var $9295=$st;
16310       var $9296=(($9295+4)|0);
16311       var $9297=$9296;
16312       var $9298=HEAP16[(($9297)>>1)];
16313       var $9299=(($9298)&65535);
16314       var $9300=(($9294+($9299<<2))|0);
16315       var $9301=$9300;
16316       var $9302=$9301;
16317       var $9303=HEAPF32[(($9302)>>2)];
16318       var $9304=$2;
16319       var $9305=(($9304+64)|0);
16320       var $9306=HEAP32[(($9305)>>2)];
16321       var $9307=$st;
16322       var $9308=(($9307+2)|0);
16323       var $9309=$9308;
16324       var $9310=HEAP16[(($9309)>>1)];
16325       var $9311=(($9310)&65535);
16326       var $9312=(($9306+($9311<<2))|0);
16327       var $9313=$9312;
16328       var $9314=$9313;
16329       var $9315=(($9314)|0);
16330       var $9316=HEAPF32[(($9315)>>2)];
16331       var $9317=($9303)*($9316);
16332       var $9318=$2;
16333       var $9319=(($9318+64)|0);
16334       var $9320=HEAP32[(($9319)>>2)];
16335       var $9321=$st;
16336       var $9322=(($9321+6)|0);
16337       var $9323=$9322;
16338       var $9324=HEAP16[(($9323)>>1)];
16339       var $9325=(($9324)&65535);
16340       var $9326=(($9320+($9325<<2))|0);
16341       var $9327=$9326;
16342       var $9328=$9327;
16343       var $9329=(($9328)|0);
16344       HEAPF32[(($9329)>>2)]=$9317;
16345       var $9330=$2;
16346       var $9331=(($9330+64)|0);
16347       var $9332=HEAP32[(($9331)>>2)];
16348       var $9333=$st;
16349       var $9334=(($9333+4)|0);
16350       var $9335=$9334;
16351       var $9336=HEAP16[(($9335)>>1)];
16352       var $9337=(($9336)&65535);
16353       var $9338=(($9332+($9337<<2))|0);
16354       var $9339=$9338;
16355       var $9340=$9339;
16356       var $9341=HEAPF32[(($9340)>>2)];
16357       var $9342=$2;
16358       var $9343=(($9342+64)|0);
16359       var $9344=HEAP32[(($9343)>>2)];
16360       var $9345=$st;
16361       var $9346=(($9345+2)|0);
16362       var $9347=$9346;
16363       var $9348=HEAP16[(($9347)>>1)];
16364       var $9349=(($9348)&65535);
16365       var $9350=(($9344+($9349<<2))|0);
16366       var $9351=$9350;
16367       var $9352=$9351;
16368       var $9353=(($9352+4)|0);
16369       var $9354=HEAPF32[(($9353)>>2)];
16370       var $9355=($9341)*($9354);
16371       var $9356=$2;
16372       var $9357=(($9356+64)|0);
16373       var $9358=HEAP32[(($9357)>>2)];
16374       var $9359=$st;
16375       var $9360=(($9359+6)|0);
16376       var $9361=$9360;
16377       var $9362=HEAP16[(($9361)>>1)];
16378       var $9363=(($9362)&65535);
16379       var $9364=(($9358+($9363<<2))|0);
16380       var $9365=$9364;
16381       var $9366=$9365;
16382       var $9367=(($9366+4)|0);
16383       HEAPF32[(($9367)>>2)]=$9355;
16384       var $9368=$2;
16385       var $9369=(($9368+64)|0);
16386       var $9370=HEAP32[(($9369)>>2)];
16387       var $9371=$st;
16388       var $9372=(($9371+4)|0);
16389       var $9373=$9372;
16390       var $9374=HEAP16[(($9373)>>1)];
16391       var $9375=(($9374)&65535);
16392       var $9376=(($9370+($9375<<2))|0);
16393       var $9377=$9376;
16394       var $9378=$9377;
16395       var $9379=HEAPF32[(($9378)>>2)];
16396       var $9380=$2;
16397       var $9381=(($9380+64)|0);
16398       var $9382=HEAP32[(($9381)>>2)];
16399       var $9383=$st;
16400       var $9384=(($9383+2)|0);
16401       var $9385=$9384;
16402       var $9386=HEAP16[(($9385)>>1)];
16403       var $9387=(($9386)&65535);
16404       var $9388=(($9382+($9387<<2))|0);
16405       var $9389=$9388;
16406       var $9390=$9389;
16407       var $9391=(($9390+8)|0);
16408       var $9392=HEAPF32[(($9391)>>2)];
16409       var $9393=($9379)*($9392);
16410       var $9394=$2;
16411       var $9395=(($9394+64)|0);
16412       var $9396=HEAP32[(($9395)>>2)];
16413       var $9397=$st;
16414       var $9398=(($9397+6)|0);
16415       var $9399=$9398;
16416       var $9400=HEAP16[(($9399)>>1)];
16417       var $9401=(($9400)&65535);
16418       var $9402=(($9396+($9401<<2))|0);
16419       var $9403=$9402;
16420       var $9404=$9403;
16421       var $9405=(($9404+8)|0);
16422       HEAPF32[(($9405)>>2)]=$9393;
16423       __label__ = 487; break;
16424     case 377:
16425       var $9407=$2;
16426       var $9408=(($9407+64)|0);
16427       var $9409=HEAP32[(($9408)>>2)];
16428       var $9410=$st;
16429       var $9411=(($9410+4)|0);
16430       var $9412=$9411;
16431       var $9413=HEAP16[(($9412)>>1)];
16432       var $9414=(($9413)&65535);
16433       var $9415=(($9409+($9414<<2))|0);
16434       var $9416=$9415;
16435       var $9417=$9416;
16436       var $9418=HEAPF32[(($9417)>>2)];
16437       var $9419=$9418 != 0;
16438       if ($9419) { __label__ = 378; break; } else { __label__ = 379; break; }
16439     case 378:
16440       var $9421=$2;
16441       var $9422=(($9421+64)|0);
16442       var $9423=HEAP32[(($9422)>>2)];
16443       var $9424=$st;
16444       var $9425=(($9424+2)|0);
16445       var $9426=$9425;
16446       var $9427=HEAP16[(($9426)>>1)];
16447       var $9428=(($9427)&65535);
16448       var $9429=(($9423+($9428<<2))|0);
16449       var $9430=$9429;
16450       var $9431=$9430;
16451       var $9432=HEAPF32[(($9431)>>2)];
16452       var $9433=$2;
16453       var $9434=(($9433+64)|0);
16454       var $9435=HEAP32[(($9434)>>2)];
16455       var $9436=$st;
16456       var $9437=(($9436+4)|0);
16457       var $9438=$9437;
16458       var $9439=HEAP16[(($9438)>>1)];
16459       var $9440=(($9439)&65535);
16460       var $9441=(($9435+($9440<<2))|0);
16461       var $9442=$9441;
16462       var $9443=$9442;
16463       var $9444=HEAPF32[(($9443)>>2)];
16464       var $9445=($9432)/($9444);
16465       var $9446=$2;
16466       var $9447=(($9446+64)|0);
16467       var $9448=HEAP32[(($9447)>>2)];
16468       var $9449=$st;
16469       var $9450=(($9449+6)|0);
16470       var $9451=$9450;
16471       var $9452=HEAP16[(($9451)>>1)];
16472       var $9453=(($9452)&65535);
16473       var $9454=(($9448+($9453<<2))|0);
16474       var $9455=$9454;
16475       var $9456=$9455;
16476       HEAPF32[(($9456)>>2)]=$9445;
16477       __label__ = 380; break;
16478     case 379:
16479       var $9458=$2;
16480       var $9459=(($9458+64)|0);
16481       var $9460=HEAP32[(($9459)>>2)];
16482       var $9461=$st;
16483       var $9462=(($9461+6)|0);
16484       var $9463=$9462;
16485       var $9464=HEAP16[(($9463)>>1)];
16486       var $9465=(($9464)&65535);
16487       var $9466=(($9460+($9465<<2))|0);
16488       var $9467=$9466;
16489       var $9468=$9467;
16490       HEAPF32[(($9468)>>2)]=0;
16491       __label__ = 380; break;
16492     case 380:
16493       __label__ = 487; break;
16494     case 381:
16495       var $9471=$2;
16496       var $9472=(($9471+64)|0);
16497       var $9473=HEAP32[(($9472)>>2)];
16498       var $9474=$st;
16499       var $9475=(($9474+2)|0);
16500       var $9476=$9475;
16501       var $9477=HEAP16[(($9476)>>1)];
16502       var $9478=(($9477)&65535);
16503       var $9479=(($9473+($9478<<2))|0);
16504       var $9480=$9479;
16505       var $9481=$9480;
16506       var $9482=HEAPF32[(($9481)>>2)];
16507       var $9483=$2;
16508       var $9484=(($9483+64)|0);
16509       var $9485=HEAP32[(($9484)>>2)];
16510       var $9486=$st;
16511       var $9487=(($9486+4)|0);
16512       var $9488=$9487;
16513       var $9489=HEAP16[(($9488)>>1)];
16514       var $9490=(($9489)&65535);
16515       var $9491=(($9485+($9490<<2))|0);
16516       var $9492=$9491;
16517       var $9493=$9492;
16518       var $9494=HEAPF32[(($9493)>>2)];
16519       var $9495=($9482)+($9494);
16520       var $9496=$2;
16521       var $9497=(($9496+64)|0);
16522       var $9498=HEAP32[(($9497)>>2)];
16523       var $9499=$st;
16524       var $9500=(($9499+6)|0);
16525       var $9501=$9500;
16526       var $9502=HEAP16[(($9501)>>1)];
16527       var $9503=(($9502)&65535);
16528       var $9504=(($9498+($9503<<2))|0);
16529       var $9505=$9504;
16530       var $9506=$9505;
16531       HEAPF32[(($9506)>>2)]=$9495;
16532       __label__ = 487; break;
16533     case 382:
16534       var $9508=$2;
16535       var $9509=(($9508+64)|0);
16536       var $9510=HEAP32[(($9509)>>2)];
16537       var $9511=$st;
16538       var $9512=(($9511+2)|0);
16539       var $9513=$9512;
16540       var $9514=HEAP16[(($9513)>>1)];
16541       var $9515=(($9514)&65535);
16542       var $9516=(($9510+($9515<<2))|0);
16543       var $9517=$9516;
16544       var $9518=$9517;
16545       var $9519=(($9518)|0);
16546       var $9520=HEAPF32[(($9519)>>2)];
16547       var $9521=$2;
16548       var $9522=(($9521+64)|0);
16549       var $9523=HEAP32[(($9522)>>2)];
16550       var $9524=$st;
16551       var $9525=(($9524+4)|0);
16552       var $9526=$9525;
16553       var $9527=HEAP16[(($9526)>>1)];
16554       var $9528=(($9527)&65535);
16555       var $9529=(($9523+($9528<<2))|0);
16556       var $9530=$9529;
16557       var $9531=$9530;
16558       var $9532=(($9531)|0);
16559       var $9533=HEAPF32[(($9532)>>2)];
16560       var $9534=($9520)+($9533);
16561       var $9535=$2;
16562       var $9536=(($9535+64)|0);
16563       var $9537=HEAP32[(($9536)>>2)];
16564       var $9538=$st;
16565       var $9539=(($9538+6)|0);
16566       var $9540=$9539;
16567       var $9541=HEAP16[(($9540)>>1)];
16568       var $9542=(($9541)&65535);
16569       var $9543=(($9537+($9542<<2))|0);
16570       var $9544=$9543;
16571       var $9545=$9544;
16572       var $9546=(($9545)|0);
16573       HEAPF32[(($9546)>>2)]=$9534;
16574       var $9547=$2;
16575       var $9548=(($9547+64)|0);
16576       var $9549=HEAP32[(($9548)>>2)];
16577       var $9550=$st;
16578       var $9551=(($9550+2)|0);
16579       var $9552=$9551;
16580       var $9553=HEAP16[(($9552)>>1)];
16581       var $9554=(($9553)&65535);
16582       var $9555=(($9549+($9554<<2))|0);
16583       var $9556=$9555;
16584       var $9557=$9556;
16585       var $9558=(($9557+4)|0);
16586       var $9559=HEAPF32[(($9558)>>2)];
16587       var $9560=$2;
16588       var $9561=(($9560+64)|0);
16589       var $9562=HEAP32[(($9561)>>2)];
16590       var $9563=$st;
16591       var $9564=(($9563+4)|0);
16592       var $9565=$9564;
16593       var $9566=HEAP16[(($9565)>>1)];
16594       var $9567=(($9566)&65535);
16595       var $9568=(($9562+($9567<<2))|0);
16596       var $9569=$9568;
16597       var $9570=$9569;
16598       var $9571=(($9570+4)|0);
16599       var $9572=HEAPF32[(($9571)>>2)];
16600       var $9573=($9559)+($9572);
16601       var $9574=$2;
16602       var $9575=(($9574+64)|0);
16603       var $9576=HEAP32[(($9575)>>2)];
16604       var $9577=$st;
16605       var $9578=(($9577+6)|0);
16606       var $9579=$9578;
16607       var $9580=HEAP16[(($9579)>>1)];
16608       var $9581=(($9580)&65535);
16609       var $9582=(($9576+($9581<<2))|0);
16610       var $9583=$9582;
16611       var $9584=$9583;
16612       var $9585=(($9584+4)|0);
16613       HEAPF32[(($9585)>>2)]=$9573;
16614       var $9586=$2;
16615       var $9587=(($9586+64)|0);
16616       var $9588=HEAP32[(($9587)>>2)];
16617       var $9589=$st;
16618       var $9590=(($9589+2)|0);
16619       var $9591=$9590;
16620       var $9592=HEAP16[(($9591)>>1)];
16621       var $9593=(($9592)&65535);
16622       var $9594=(($9588+($9593<<2))|0);
16623       var $9595=$9594;
16624       var $9596=$9595;
16625       var $9597=(($9596+8)|0);
16626       var $9598=HEAPF32[(($9597)>>2)];
16627       var $9599=$2;
16628       var $9600=(($9599+64)|0);
16629       var $9601=HEAP32[(($9600)>>2)];
16630       var $9602=$st;
16631       var $9603=(($9602+4)|0);
16632       var $9604=$9603;
16633       var $9605=HEAP16[(($9604)>>1)];
16634       var $9606=(($9605)&65535);
16635       var $9607=(($9601+($9606<<2))|0);
16636       var $9608=$9607;
16637       var $9609=$9608;
16638       var $9610=(($9609+8)|0);
16639       var $9611=HEAPF32[(($9610)>>2)];
16640       var $9612=($9598)+($9611);
16641       var $9613=$2;
16642       var $9614=(($9613+64)|0);
16643       var $9615=HEAP32[(($9614)>>2)];
16644       var $9616=$st;
16645       var $9617=(($9616+6)|0);
16646       var $9618=$9617;
16647       var $9619=HEAP16[(($9618)>>1)];
16648       var $9620=(($9619)&65535);
16649       var $9621=(($9615+($9620<<2))|0);
16650       var $9622=$9621;
16651       var $9623=$9622;
16652       var $9624=(($9623+8)|0);
16653       HEAPF32[(($9624)>>2)]=$9612;
16654       __label__ = 487; break;
16655     case 383:
16656       var $9626=$2;
16657       var $9627=(($9626+64)|0);
16658       var $9628=HEAP32[(($9627)>>2)];
16659       var $9629=$st;
16660       var $9630=(($9629+2)|0);
16661       var $9631=$9630;
16662       var $9632=HEAP16[(($9631)>>1)];
16663       var $9633=(($9632)&65535);
16664       var $9634=(($9628+($9633<<2))|0);
16665       var $9635=$9634;
16666       var $9636=$9635;
16667       var $9637=HEAPF32[(($9636)>>2)];
16668       var $9638=$2;
16669       var $9639=(($9638+64)|0);
16670       var $9640=HEAP32[(($9639)>>2)];
16671       var $9641=$st;
16672       var $9642=(($9641+4)|0);
16673       var $9643=$9642;
16674       var $9644=HEAP16[(($9643)>>1)];
16675       var $9645=(($9644)&65535);
16676       var $9646=(($9640+($9645<<2))|0);
16677       var $9647=$9646;
16678       var $9648=$9647;
16679       var $9649=HEAPF32[(($9648)>>2)];
16680       var $9650=($9637)-($9649);
16681       var $9651=$2;
16682       var $9652=(($9651+64)|0);
16683       var $9653=HEAP32[(($9652)>>2)];
16684       var $9654=$st;
16685       var $9655=(($9654+6)|0);
16686       var $9656=$9655;
16687       var $9657=HEAP16[(($9656)>>1)];
16688       var $9658=(($9657)&65535);
16689       var $9659=(($9653+($9658<<2))|0);
16690       var $9660=$9659;
16691       var $9661=$9660;
16692       HEAPF32[(($9661)>>2)]=$9650;
16693       __label__ = 487; break;
16694     case 384:
16695       var $9663=$2;
16696       var $9664=(($9663+64)|0);
16697       var $9665=HEAP32[(($9664)>>2)];
16698       var $9666=$st;
16699       var $9667=(($9666+2)|0);
16700       var $9668=$9667;
16701       var $9669=HEAP16[(($9668)>>1)];
16702       var $9670=(($9669)&65535);
16703       var $9671=(($9665+($9670<<2))|0);
16704       var $9672=$9671;
16705       var $9673=$9672;
16706       var $9674=(($9673)|0);
16707       var $9675=HEAPF32[(($9674)>>2)];
16708       var $9676=$2;
16709       var $9677=(($9676+64)|0);
16710       var $9678=HEAP32[(($9677)>>2)];
16711       var $9679=$st;
16712       var $9680=(($9679+4)|0);
16713       var $9681=$9680;
16714       var $9682=HEAP16[(($9681)>>1)];
16715       var $9683=(($9682)&65535);
16716       var $9684=(($9678+($9683<<2))|0);
16717       var $9685=$9684;
16718       var $9686=$9685;
16719       var $9687=(($9686)|0);
16720       var $9688=HEAPF32[(($9687)>>2)];
16721       var $9689=($9675)-($9688);
16722       var $9690=$2;
16723       var $9691=(($9690+64)|0);
16724       var $9692=HEAP32[(($9691)>>2)];
16725       var $9693=$st;
16726       var $9694=(($9693+6)|0);
16727       var $9695=$9694;
16728       var $9696=HEAP16[(($9695)>>1)];
16729       var $9697=(($9696)&65535);
16730       var $9698=(($9692+($9697<<2))|0);
16731       var $9699=$9698;
16732       var $9700=$9699;
16733       var $9701=(($9700)|0);
16734       HEAPF32[(($9701)>>2)]=$9689;
16735       var $9702=$2;
16736       var $9703=(($9702+64)|0);
16737       var $9704=HEAP32[(($9703)>>2)];
16738       var $9705=$st;
16739       var $9706=(($9705+2)|0);
16740       var $9707=$9706;
16741       var $9708=HEAP16[(($9707)>>1)];
16742       var $9709=(($9708)&65535);
16743       var $9710=(($9704+($9709<<2))|0);
16744       var $9711=$9710;
16745       var $9712=$9711;
16746       var $9713=(($9712+4)|0);
16747       var $9714=HEAPF32[(($9713)>>2)];
16748       var $9715=$2;
16749       var $9716=(($9715+64)|0);
16750       var $9717=HEAP32[(($9716)>>2)];
16751       var $9718=$st;
16752       var $9719=(($9718+4)|0);
16753       var $9720=$9719;
16754       var $9721=HEAP16[(($9720)>>1)];
16755       var $9722=(($9721)&65535);
16756       var $9723=(($9717+($9722<<2))|0);
16757       var $9724=$9723;
16758       var $9725=$9724;
16759       var $9726=(($9725+4)|0);
16760       var $9727=HEAPF32[(($9726)>>2)];
16761       var $9728=($9714)-($9727);
16762       var $9729=$2;
16763       var $9730=(($9729+64)|0);
16764       var $9731=HEAP32[(($9730)>>2)];
16765       var $9732=$st;
16766       var $9733=(($9732+6)|0);
16767       var $9734=$9733;
16768       var $9735=HEAP16[(($9734)>>1)];
16769       var $9736=(($9735)&65535);
16770       var $9737=(($9731+($9736<<2))|0);
16771       var $9738=$9737;
16772       var $9739=$9738;
16773       var $9740=(($9739+4)|0);
16774       HEAPF32[(($9740)>>2)]=$9728;
16775       var $9741=$2;
16776       var $9742=(($9741+64)|0);
16777       var $9743=HEAP32[(($9742)>>2)];
16778       var $9744=$st;
16779       var $9745=(($9744+2)|0);
16780       var $9746=$9745;
16781       var $9747=HEAP16[(($9746)>>1)];
16782       var $9748=(($9747)&65535);
16783       var $9749=(($9743+($9748<<2))|0);
16784       var $9750=$9749;
16785       var $9751=$9750;
16786       var $9752=(($9751+8)|0);
16787       var $9753=HEAPF32[(($9752)>>2)];
16788       var $9754=$2;
16789       var $9755=(($9754+64)|0);
16790       var $9756=HEAP32[(($9755)>>2)];
16791       var $9757=$st;
16792       var $9758=(($9757+4)|0);
16793       var $9759=$9758;
16794       var $9760=HEAP16[(($9759)>>1)];
16795       var $9761=(($9760)&65535);
16796       var $9762=(($9756+($9761<<2))|0);
16797       var $9763=$9762;
16798       var $9764=$9763;
16799       var $9765=(($9764+8)|0);
16800       var $9766=HEAPF32[(($9765)>>2)];
16801       var $9767=($9753)-($9766);
16802       var $9768=$2;
16803       var $9769=(($9768+64)|0);
16804       var $9770=HEAP32[(($9769)>>2)];
16805       var $9771=$st;
16806       var $9772=(($9771+6)|0);
16807       var $9773=$9772;
16808       var $9774=HEAP16[(($9773)>>1)];
16809       var $9775=(($9774)&65535);
16810       var $9776=(($9770+($9775<<2))|0);
16811       var $9777=$9776;
16812       var $9778=$9777;
16813       var $9779=(($9778+8)|0);
16814       HEAPF32[(($9779)>>2)]=$9767;
16815       __label__ = 487; break;
16816     case 385:
16817       var $9781=$2;
16818       var $9782=(($9781+64)|0);
16819       var $9783=HEAP32[(($9782)>>2)];
16820       var $9784=$st;
16821       var $9785=(($9784+2)|0);
16822       var $9786=$9785;
16823       var $9787=HEAP16[(($9786)>>1)];
16824       var $9788=(($9787)&65535);
16825       var $9789=(($9783+($9788<<2))|0);
16826       var $9790=$9789;
16827       var $9791=$9790;
16828       var $9792=HEAPF32[(($9791)>>2)];
16829       var $9793=$2;
16830       var $9794=(($9793+64)|0);
16831       var $9795=HEAP32[(($9794)>>2)];
16832       var $9796=$st;
16833       var $9797=(($9796+4)|0);
16834       var $9798=$9797;
16835       var $9799=HEAP16[(($9798)>>1)];
16836       var $9800=(($9799)&65535);
16837       var $9801=(($9795+($9800<<2))|0);
16838       var $9802=$9801;
16839       var $9803=$9802;
16840       var $9804=HEAPF32[(($9803)>>2)];
16841       var $9805=$9792 == $9804;
16842       var $9806=(($9805)&1);
16843       var $9807=(($9806)|0);
16844       var $9808=$2;
16845       var $9809=(($9808+64)|0);
16846       var $9810=HEAP32[(($9809)>>2)];
16847       var $9811=$st;
16848       var $9812=(($9811+6)|0);
16849       var $9813=$9812;
16850       var $9814=HEAP16[(($9813)>>1)];
16851       var $9815=(($9814)&65535);
16852       var $9816=(($9810+($9815<<2))|0);
16853       var $9817=$9816;
16854       var $9818=$9817;
16855       HEAPF32[(($9818)>>2)]=$9807;
16856       __label__ = 487; break;
16857     case 386:
16858       var $9820=$2;
16859       var $9821=(($9820+64)|0);
16860       var $9822=HEAP32[(($9821)>>2)];
16861       var $9823=$st;
16862       var $9824=(($9823+2)|0);
16863       var $9825=$9824;
16864       var $9826=HEAP16[(($9825)>>1)];
16865       var $9827=(($9826)&65535);
16866       var $9828=(($9822+($9827<<2))|0);
16867       var $9829=$9828;
16868       var $9830=$9829;
16869       var $9831=(($9830)|0);
16870       var $9832=HEAPF32[(($9831)>>2)];
16871       var $9833=$2;
16872       var $9834=(($9833+64)|0);
16873       var $9835=HEAP32[(($9834)>>2)];
16874       var $9836=$st;
16875       var $9837=(($9836+4)|0);
16876       var $9838=$9837;
16877       var $9839=HEAP16[(($9838)>>1)];
16878       var $9840=(($9839)&65535);
16879       var $9841=(($9835+($9840<<2))|0);
16880       var $9842=$9841;
16881       var $9843=$9842;
16882       var $9844=(($9843)|0);
16883       var $9845=HEAPF32[(($9844)>>2)];
16884       var $9846=$9832 == $9845;
16885       if ($9846) { __label__ = 387; break; } else { var $9904 = 0;__label__ = 389; break; }
16886     case 387:
16887       var $9848=$2;
16888       var $9849=(($9848+64)|0);
16889       var $9850=HEAP32[(($9849)>>2)];
16890       var $9851=$st;
16891       var $9852=(($9851+2)|0);
16892       var $9853=$9852;
16893       var $9854=HEAP16[(($9853)>>1)];
16894       var $9855=(($9854)&65535);
16895       var $9856=(($9850+($9855<<2))|0);
16896       var $9857=$9856;
16897       var $9858=$9857;
16898       var $9859=(($9858+4)|0);
16899       var $9860=HEAPF32[(($9859)>>2)];
16900       var $9861=$2;
16901       var $9862=(($9861+64)|0);
16902       var $9863=HEAP32[(($9862)>>2)];
16903       var $9864=$st;
16904       var $9865=(($9864+4)|0);
16905       var $9866=$9865;
16906       var $9867=HEAP16[(($9866)>>1)];
16907       var $9868=(($9867)&65535);
16908       var $9869=(($9863+($9868<<2))|0);
16909       var $9870=$9869;
16910       var $9871=$9870;
16911       var $9872=(($9871+4)|0);
16912       var $9873=HEAPF32[(($9872)>>2)];
16913       var $9874=$9860 == $9873;
16914       if ($9874) { __label__ = 388; break; } else { var $9904 = 0;__label__ = 389; break; }
16915     case 388:
16916       var $9876=$2;
16917       var $9877=(($9876+64)|0);
16918       var $9878=HEAP32[(($9877)>>2)];
16919       var $9879=$st;
16920       var $9880=(($9879+2)|0);
16921       var $9881=$9880;
16922       var $9882=HEAP16[(($9881)>>1)];
16923       var $9883=(($9882)&65535);
16924       var $9884=(($9878+($9883<<2))|0);
16925       var $9885=$9884;
16926       var $9886=$9885;
16927       var $9887=(($9886+8)|0);
16928       var $9888=HEAPF32[(($9887)>>2)];
16929       var $9889=$2;
16930       var $9890=(($9889+64)|0);
16931       var $9891=HEAP32[(($9890)>>2)];
16932       var $9892=$st;
16933       var $9893=(($9892+4)|0);
16934       var $9894=$9893;
16935       var $9895=HEAP16[(($9894)>>1)];
16936       var $9896=(($9895)&65535);
16937       var $9897=(($9891+($9896<<2))|0);
16938       var $9898=$9897;
16939       var $9899=$9898;
16940       var $9900=(($9899+8)|0);
16941       var $9901=HEAPF32[(($9900)>>2)];
16942       var $9902=$9888 == $9901;
16943       var $9904 = $9902;__label__ = 389; break;
16944     case 389:
16945       var $9904;
16946       var $9905=(($9904)&1);
16947       var $9906=(($9905)|0);
16948       var $9907=$2;
16949       var $9908=(($9907+64)|0);
16950       var $9909=HEAP32[(($9908)>>2)];
16951       var $9910=$st;
16952       var $9911=(($9910+6)|0);
16953       var $9912=$9911;
16954       var $9913=HEAP16[(($9912)>>1)];
16955       var $9914=(($9913)&65535);
16956       var $9915=(($9909+($9914<<2))|0);
16957       var $9916=$9915;
16958       var $9917=$9916;
16959       HEAPF32[(($9917)>>2)]=$9906;
16960       __label__ = 487; break;
16961     case 390:
16962       var $9919=$2;
16963       var $9920=$2;
16964       var $9921=(($9920+64)|0);
16965       var $9922=HEAP32[(($9921)>>2)];
16966       var $9923=$st;
16967       var $9924=(($9923+2)|0);
16968       var $9925=$9924;
16969       var $9926=HEAP16[(($9925)>>1)];
16970       var $9927=(($9926)&65535);
16971       var $9928=(($9922+($9927<<2))|0);
16972       var $9929=$9928;
16973       var $9930=$9929;
16974       var $9931=HEAP32[(($9930)>>2)];
16975       var $9932=_prog_getstring($9919, $9931);
16976       var $9933=$2;
16977       var $9934=$2;
16978       var $9935=(($9934+64)|0);
16979       var $9936=HEAP32[(($9935)>>2)];
16980       var $9937=$st;
16981       var $9938=(($9937+4)|0);
16982       var $9939=$9938;
16983       var $9940=HEAP16[(($9939)>>1)];
16984       var $9941=(($9940)&65535);
16985       var $9942=(($9936+($9941<<2))|0);
16986       var $9943=$9942;
16987       var $9944=$9943;
16988       var $9945=HEAP32[(($9944)>>2)];
16989       var $9946=_prog_getstring($9933, $9945);
16990       var $9947=_strcmp($9932, $9946);
16991       var $9948=(($9947)|0)!=0;
16992       var $9949=$9948 ^ 1;
16993       var $9950=(($9949)&1);
16994       var $9951=(($9950)|0);
16995       var $9952=$2;
16996       var $9953=(($9952+64)|0);
16997       var $9954=HEAP32[(($9953)>>2)];
16998       var $9955=$st;
16999       var $9956=(($9955+6)|0);
17000       var $9957=$9956;
17001       var $9958=HEAP16[(($9957)>>1)];
17002       var $9959=(($9958)&65535);
17003       var $9960=(($9954+($9959<<2))|0);
17004       var $9961=$9960;
17005       var $9962=$9961;
17006       HEAPF32[(($9962)>>2)]=$9951;
17007       __label__ = 487; break;
17008     case 391:
17009       var $9964=$2;
17010       var $9965=(($9964+64)|0);
17011       var $9966=HEAP32[(($9965)>>2)];
17012       var $9967=$st;
17013       var $9968=(($9967+2)|0);
17014       var $9969=$9968;
17015       var $9970=HEAP16[(($9969)>>1)];
17016       var $9971=(($9970)&65535);
17017       var $9972=(($9966+($9971<<2))|0);
17018       var $9973=$9972;
17019       var $9974=$9973;
17020       var $9975=HEAP32[(($9974)>>2)];
17021       var $9976=$2;
17022       var $9977=(($9976+64)|0);
17023       var $9978=HEAP32[(($9977)>>2)];
17024       var $9979=$st;
17025       var $9980=(($9979+4)|0);
17026       var $9981=$9980;
17027       var $9982=HEAP16[(($9981)>>1)];
17028       var $9983=(($9982)&65535);
17029       var $9984=(($9978+($9983<<2))|0);
17030       var $9985=$9984;
17031       var $9986=$9985;
17032       var $9987=HEAP32[(($9986)>>2)];
17033       var $9988=(($9975)|0)==(($9987)|0);
17034       var $9989=(($9988)&1);
17035       var $9990=(($9989)|0);
17036       var $9991=$2;
17037       var $9992=(($9991+64)|0);
17038       var $9993=HEAP32[(($9992)>>2)];
17039       var $9994=$st;
17040       var $9995=(($9994+6)|0);
17041       var $9996=$9995;
17042       var $9997=HEAP16[(($9996)>>1)];
17043       var $9998=(($9997)&65535);
17044       var $9999=(($9993+($9998<<2))|0);
17045       var $10000=$9999;
17046       var $10001=$10000;
17047       HEAPF32[(($10001)>>2)]=$9990;
17048       __label__ = 487; break;
17049     case 392:
17050       var $10003=$2;
17051       var $10004=(($10003+64)|0);
17052       var $10005=HEAP32[(($10004)>>2)];
17053       var $10006=$st;
17054       var $10007=(($10006+2)|0);
17055       var $10008=$10007;
17056       var $10009=HEAP16[(($10008)>>1)];
17057       var $10010=(($10009)&65535);
17058       var $10011=(($10005+($10010<<2))|0);
17059       var $10012=$10011;
17060       var $10013=$10012;
17061       var $10014=HEAP32[(($10013)>>2)];
17062       var $10015=$2;
17063       var $10016=(($10015+64)|0);
17064       var $10017=HEAP32[(($10016)>>2)];
17065       var $10018=$st;
17066       var $10019=(($10018+4)|0);
17067       var $10020=$10019;
17068       var $10021=HEAP16[(($10020)>>1)];
17069       var $10022=(($10021)&65535);
17070       var $10023=(($10017+($10022<<2))|0);
17071       var $10024=$10023;
17072       var $10025=$10024;
17073       var $10026=HEAP32[(($10025)>>2)];
17074       var $10027=(($10014)|0)==(($10026)|0);
17075       var $10028=(($10027)&1);
17076       var $10029=(($10028)|0);
17077       var $10030=$2;
17078       var $10031=(($10030+64)|0);
17079       var $10032=HEAP32[(($10031)>>2)];
17080       var $10033=$st;
17081       var $10034=(($10033+6)|0);
17082       var $10035=$10034;
17083       var $10036=HEAP16[(($10035)>>1)];
17084       var $10037=(($10036)&65535);
17085       var $10038=(($10032+($10037<<2))|0);
17086       var $10039=$10038;
17087       var $10040=$10039;
17088       HEAPF32[(($10040)>>2)]=$10029;
17089       __label__ = 487; break;
17090     case 393:
17091       var $10042=$2;
17092       var $10043=(($10042+64)|0);
17093       var $10044=HEAP32[(($10043)>>2)];
17094       var $10045=$st;
17095       var $10046=(($10045+2)|0);
17096       var $10047=$10046;
17097       var $10048=HEAP16[(($10047)>>1)];
17098       var $10049=(($10048)&65535);
17099       var $10050=(($10044+($10049<<2))|0);
17100       var $10051=$10050;
17101       var $10052=$10051;
17102       var $10053=HEAPF32[(($10052)>>2)];
17103       var $10054=$2;
17104       var $10055=(($10054+64)|0);
17105       var $10056=HEAP32[(($10055)>>2)];
17106       var $10057=$st;
17107       var $10058=(($10057+4)|0);
17108       var $10059=$10058;
17109       var $10060=HEAP16[(($10059)>>1)];
17110       var $10061=(($10060)&65535);
17111       var $10062=(($10056+($10061<<2))|0);
17112       var $10063=$10062;
17113       var $10064=$10063;
17114       var $10065=HEAPF32[(($10064)>>2)];
17115       var $10066=$10053 != $10065;
17116       var $10067=(($10066)&1);
17117       var $10068=(($10067)|0);
17118       var $10069=$2;
17119       var $10070=(($10069+64)|0);
17120       var $10071=HEAP32[(($10070)>>2)];
17121       var $10072=$st;
17122       var $10073=(($10072+6)|0);
17123       var $10074=$10073;
17124       var $10075=HEAP16[(($10074)>>1)];
17125       var $10076=(($10075)&65535);
17126       var $10077=(($10071+($10076<<2))|0);
17127       var $10078=$10077;
17128       var $10079=$10078;
17129       HEAPF32[(($10079)>>2)]=$10068;
17130       __label__ = 487; break;
17131     case 394:
17132       var $10081=$2;
17133       var $10082=(($10081+64)|0);
17134       var $10083=HEAP32[(($10082)>>2)];
17135       var $10084=$st;
17136       var $10085=(($10084+2)|0);
17137       var $10086=$10085;
17138       var $10087=HEAP16[(($10086)>>1)];
17139       var $10088=(($10087)&65535);
17140       var $10089=(($10083+($10088<<2))|0);
17141       var $10090=$10089;
17142       var $10091=$10090;
17143       var $10092=(($10091)|0);
17144       var $10093=HEAPF32[(($10092)>>2)];
17145       var $10094=$2;
17146       var $10095=(($10094+64)|0);
17147       var $10096=HEAP32[(($10095)>>2)];
17148       var $10097=$st;
17149       var $10098=(($10097+4)|0);
17150       var $10099=$10098;
17151       var $10100=HEAP16[(($10099)>>1)];
17152       var $10101=(($10100)&65535);
17153       var $10102=(($10096+($10101<<2))|0);
17154       var $10103=$10102;
17155       var $10104=$10103;
17156       var $10105=(($10104)|0);
17157       var $10106=HEAPF32[(($10105)>>2)];
17158       var $10107=$10093 != $10106;
17159       if ($10107) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 395; break; }
17160     case 395:
17161       var $10109=$2;
17162       var $10110=(($10109+64)|0);
17163       var $10111=HEAP32[(($10110)>>2)];
17164       var $10112=$st;
17165       var $10113=(($10112+2)|0);
17166       var $10114=$10113;
17167       var $10115=HEAP16[(($10114)>>1)];
17168       var $10116=(($10115)&65535);
17169       var $10117=(($10111+($10116<<2))|0);
17170       var $10118=$10117;
17171       var $10119=$10118;
17172       var $10120=(($10119+4)|0);
17173       var $10121=HEAPF32[(($10120)>>2)];
17174       var $10122=$2;
17175       var $10123=(($10122+64)|0);
17176       var $10124=HEAP32[(($10123)>>2)];
17177       var $10125=$st;
17178       var $10126=(($10125+4)|0);
17179       var $10127=$10126;
17180       var $10128=HEAP16[(($10127)>>1)];
17181       var $10129=(($10128)&65535);
17182       var $10130=(($10124+($10129<<2))|0);
17183       var $10131=$10130;
17184       var $10132=$10131;
17185       var $10133=(($10132+4)|0);
17186       var $10134=HEAPF32[(($10133)>>2)];
17187       var $10135=$10121 != $10134;
17188       if ($10135) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 396; break; }
17189     case 396:
17190       var $10137=$2;
17191       var $10138=(($10137+64)|0);
17192       var $10139=HEAP32[(($10138)>>2)];
17193       var $10140=$st;
17194       var $10141=(($10140+2)|0);
17195       var $10142=$10141;
17196       var $10143=HEAP16[(($10142)>>1)];
17197       var $10144=(($10143)&65535);
17198       var $10145=(($10139+($10144<<2))|0);
17199       var $10146=$10145;
17200       var $10147=$10146;
17201       var $10148=(($10147+8)|0);
17202       var $10149=HEAPF32[(($10148)>>2)];
17203       var $10150=$2;
17204       var $10151=(($10150+64)|0);
17205       var $10152=HEAP32[(($10151)>>2)];
17206       var $10153=$st;
17207       var $10154=(($10153+4)|0);
17208       var $10155=$10154;
17209       var $10156=HEAP16[(($10155)>>1)];
17210       var $10157=(($10156)&65535);
17211       var $10158=(($10152+($10157<<2))|0);
17212       var $10159=$10158;
17213       var $10160=$10159;
17214       var $10161=(($10160+8)|0);
17215       var $10162=HEAPF32[(($10161)>>2)];
17216       var $10163=$10149 != $10162;
17217       var $10165 = $10163;__label__ = 397; break;
17218     case 397:
17219       var $10165;
17220       var $10166=(($10165)&1);
17221       var $10167=(($10166)|0);
17222       var $10168=$2;
17223       var $10169=(($10168+64)|0);
17224       var $10170=HEAP32[(($10169)>>2)];
17225       var $10171=$st;
17226       var $10172=(($10171+6)|0);
17227       var $10173=$10172;
17228       var $10174=HEAP16[(($10173)>>1)];
17229       var $10175=(($10174)&65535);
17230       var $10176=(($10170+($10175<<2))|0);
17231       var $10177=$10176;
17232       var $10178=$10177;
17233       HEAPF32[(($10178)>>2)]=$10167;
17234       __label__ = 487; break;
17235     case 398:
17236       var $10180=$2;
17237       var $10181=$2;
17238       var $10182=(($10181+64)|0);
17239       var $10183=HEAP32[(($10182)>>2)];
17240       var $10184=$st;
17241       var $10185=(($10184+2)|0);
17242       var $10186=$10185;
17243       var $10187=HEAP16[(($10186)>>1)];
17244       var $10188=(($10187)&65535);
17245       var $10189=(($10183+($10188<<2))|0);
17246       var $10190=$10189;
17247       var $10191=$10190;
17248       var $10192=HEAP32[(($10191)>>2)];
17249       var $10193=_prog_getstring($10180, $10192);
17250       var $10194=$2;
17251       var $10195=$2;
17252       var $10196=(($10195+64)|0);
17253       var $10197=HEAP32[(($10196)>>2)];
17254       var $10198=$st;
17255       var $10199=(($10198+4)|0);
17256       var $10200=$10199;
17257       var $10201=HEAP16[(($10200)>>1)];
17258       var $10202=(($10201)&65535);
17259       var $10203=(($10197+($10202<<2))|0);
17260       var $10204=$10203;
17261       var $10205=$10204;
17262       var $10206=HEAP32[(($10205)>>2)];
17263       var $10207=_prog_getstring($10194, $10206);
17264       var $10208=_strcmp($10193, $10207);
17265       var $10209=(($10208)|0)!=0;
17266       var $10210=$10209 ^ 1;
17267       var $10211=$10210 ^ 1;
17268       var $10212=(($10211)&1);
17269       var $10213=(($10212)|0);
17270       var $10214=$2;
17271       var $10215=(($10214+64)|0);
17272       var $10216=HEAP32[(($10215)>>2)];
17273       var $10217=$st;
17274       var $10218=(($10217+6)|0);
17275       var $10219=$10218;
17276       var $10220=HEAP16[(($10219)>>1)];
17277       var $10221=(($10220)&65535);
17278       var $10222=(($10216+($10221<<2))|0);
17279       var $10223=$10222;
17280       var $10224=$10223;
17281       HEAPF32[(($10224)>>2)]=$10213;
17282       __label__ = 487; break;
17283     case 399:
17284       var $10226=$2;
17285       var $10227=(($10226+64)|0);
17286       var $10228=HEAP32[(($10227)>>2)];
17287       var $10229=$st;
17288       var $10230=(($10229+2)|0);
17289       var $10231=$10230;
17290       var $10232=HEAP16[(($10231)>>1)];
17291       var $10233=(($10232)&65535);
17292       var $10234=(($10228+($10233<<2))|0);
17293       var $10235=$10234;
17294       var $10236=$10235;
17295       var $10237=HEAP32[(($10236)>>2)];
17296       var $10238=$2;
17297       var $10239=(($10238+64)|0);
17298       var $10240=HEAP32[(($10239)>>2)];
17299       var $10241=$st;
17300       var $10242=(($10241+4)|0);
17301       var $10243=$10242;
17302       var $10244=HEAP16[(($10243)>>1)];
17303       var $10245=(($10244)&65535);
17304       var $10246=(($10240+($10245<<2))|0);
17305       var $10247=$10246;
17306       var $10248=$10247;
17307       var $10249=HEAP32[(($10248)>>2)];
17308       var $10250=(($10237)|0)!=(($10249)|0);
17309       var $10251=(($10250)&1);
17310       var $10252=(($10251)|0);
17311       var $10253=$2;
17312       var $10254=(($10253+64)|0);
17313       var $10255=HEAP32[(($10254)>>2)];
17314       var $10256=$st;
17315       var $10257=(($10256+6)|0);
17316       var $10258=$10257;
17317       var $10259=HEAP16[(($10258)>>1)];
17318       var $10260=(($10259)&65535);
17319       var $10261=(($10255+($10260<<2))|0);
17320       var $10262=$10261;
17321       var $10263=$10262;
17322       HEAPF32[(($10263)>>2)]=$10252;
17323       __label__ = 487; break;
17324     case 400:
17325       var $10265=$2;
17326       var $10266=(($10265+64)|0);
17327       var $10267=HEAP32[(($10266)>>2)];
17328       var $10268=$st;
17329       var $10269=(($10268+2)|0);
17330       var $10270=$10269;
17331       var $10271=HEAP16[(($10270)>>1)];
17332       var $10272=(($10271)&65535);
17333       var $10273=(($10267+($10272<<2))|0);
17334       var $10274=$10273;
17335       var $10275=$10274;
17336       var $10276=HEAP32[(($10275)>>2)];
17337       var $10277=$2;
17338       var $10278=(($10277+64)|0);
17339       var $10279=HEAP32[(($10278)>>2)];
17340       var $10280=$st;
17341       var $10281=(($10280+4)|0);
17342       var $10282=$10281;
17343       var $10283=HEAP16[(($10282)>>1)];
17344       var $10284=(($10283)&65535);
17345       var $10285=(($10279+($10284<<2))|0);
17346       var $10286=$10285;
17347       var $10287=$10286;
17348       var $10288=HEAP32[(($10287)>>2)];
17349       var $10289=(($10276)|0)!=(($10288)|0);
17350       var $10290=(($10289)&1);
17351       var $10291=(($10290)|0);
17352       var $10292=$2;
17353       var $10293=(($10292+64)|0);
17354       var $10294=HEAP32[(($10293)>>2)];
17355       var $10295=$st;
17356       var $10296=(($10295+6)|0);
17357       var $10297=$10296;
17358       var $10298=HEAP16[(($10297)>>1)];
17359       var $10299=(($10298)&65535);
17360       var $10300=(($10294+($10299<<2))|0);
17361       var $10301=$10300;
17362       var $10302=$10301;
17363       HEAPF32[(($10302)>>2)]=$10291;
17364       __label__ = 487; break;
17365     case 401:
17366       var $10304=$2;
17367       var $10305=(($10304+64)|0);
17368       var $10306=HEAP32[(($10305)>>2)];
17369       var $10307=$st;
17370       var $10308=(($10307+2)|0);
17371       var $10309=$10308;
17372       var $10310=HEAP16[(($10309)>>1)];
17373       var $10311=(($10310)&65535);
17374       var $10312=(($10306+($10311<<2))|0);
17375       var $10313=$10312;
17376       var $10314=$10313;
17377       var $10315=HEAPF32[(($10314)>>2)];
17378       var $10316=$2;
17379       var $10317=(($10316+64)|0);
17380       var $10318=HEAP32[(($10317)>>2)];
17381       var $10319=$st;
17382       var $10320=(($10319+4)|0);
17383       var $10321=$10320;
17384       var $10322=HEAP16[(($10321)>>1)];
17385       var $10323=(($10322)&65535);
17386       var $10324=(($10318+($10323<<2))|0);
17387       var $10325=$10324;
17388       var $10326=$10325;
17389       var $10327=HEAPF32[(($10326)>>2)];
17390       var $10328=$10315 <= $10327;
17391       var $10329=(($10328)&1);
17392       var $10330=(($10329)|0);
17393       var $10331=$2;
17394       var $10332=(($10331+64)|0);
17395       var $10333=HEAP32[(($10332)>>2)];
17396       var $10334=$st;
17397       var $10335=(($10334+6)|0);
17398       var $10336=$10335;
17399       var $10337=HEAP16[(($10336)>>1)];
17400       var $10338=(($10337)&65535);
17401       var $10339=(($10333+($10338<<2))|0);
17402       var $10340=$10339;
17403       var $10341=$10340;
17404       HEAPF32[(($10341)>>2)]=$10330;
17405       __label__ = 487; break;
17406     case 402:
17407       var $10343=$2;
17408       var $10344=(($10343+64)|0);
17409       var $10345=HEAP32[(($10344)>>2)];
17410       var $10346=$st;
17411       var $10347=(($10346+2)|0);
17412       var $10348=$10347;
17413       var $10349=HEAP16[(($10348)>>1)];
17414       var $10350=(($10349)&65535);
17415       var $10351=(($10345+($10350<<2))|0);
17416       var $10352=$10351;
17417       var $10353=$10352;
17418       var $10354=HEAPF32[(($10353)>>2)];
17419       var $10355=$2;
17420       var $10356=(($10355+64)|0);
17421       var $10357=HEAP32[(($10356)>>2)];
17422       var $10358=$st;
17423       var $10359=(($10358+4)|0);
17424       var $10360=$10359;
17425       var $10361=HEAP16[(($10360)>>1)];
17426       var $10362=(($10361)&65535);
17427       var $10363=(($10357+($10362<<2))|0);
17428       var $10364=$10363;
17429       var $10365=$10364;
17430       var $10366=HEAPF32[(($10365)>>2)];
17431       var $10367=$10354 >= $10366;
17432       var $10368=(($10367)&1);
17433       var $10369=(($10368)|0);
17434       var $10370=$2;
17435       var $10371=(($10370+64)|0);
17436       var $10372=HEAP32[(($10371)>>2)];
17437       var $10373=$st;
17438       var $10374=(($10373+6)|0);
17439       var $10375=$10374;
17440       var $10376=HEAP16[(($10375)>>1)];
17441       var $10377=(($10376)&65535);
17442       var $10378=(($10372+($10377<<2))|0);
17443       var $10379=$10378;
17444       var $10380=$10379;
17445       HEAPF32[(($10380)>>2)]=$10369;
17446       __label__ = 487; break;
17447     case 403:
17448       var $10382=$2;
17449       var $10383=(($10382+64)|0);
17450       var $10384=HEAP32[(($10383)>>2)];
17451       var $10385=$st;
17452       var $10386=(($10385+2)|0);
17453       var $10387=$10386;
17454       var $10388=HEAP16[(($10387)>>1)];
17455       var $10389=(($10388)&65535);
17456       var $10390=(($10384+($10389<<2))|0);
17457       var $10391=$10390;
17458       var $10392=$10391;
17459       var $10393=HEAPF32[(($10392)>>2)];
17460       var $10394=$2;
17461       var $10395=(($10394+64)|0);
17462       var $10396=HEAP32[(($10395)>>2)];
17463       var $10397=$st;
17464       var $10398=(($10397+4)|0);
17465       var $10399=$10398;
17466       var $10400=HEAP16[(($10399)>>1)];
17467       var $10401=(($10400)&65535);
17468       var $10402=(($10396+($10401<<2))|0);
17469       var $10403=$10402;
17470       var $10404=$10403;
17471       var $10405=HEAPF32[(($10404)>>2)];
17472       var $10406=$10393 < $10405;
17473       var $10407=(($10406)&1);
17474       var $10408=(($10407)|0);
17475       var $10409=$2;
17476       var $10410=(($10409+64)|0);
17477       var $10411=HEAP32[(($10410)>>2)];
17478       var $10412=$st;
17479       var $10413=(($10412+6)|0);
17480       var $10414=$10413;
17481       var $10415=HEAP16[(($10414)>>1)];
17482       var $10416=(($10415)&65535);
17483       var $10417=(($10411+($10416<<2))|0);
17484       var $10418=$10417;
17485       var $10419=$10418;
17486       HEAPF32[(($10419)>>2)]=$10408;
17487       __label__ = 487; break;
17488     case 404:
17489       var $10421=$2;
17490       var $10422=(($10421+64)|0);
17491       var $10423=HEAP32[(($10422)>>2)];
17492       var $10424=$st;
17493       var $10425=(($10424+2)|0);
17494       var $10426=$10425;
17495       var $10427=HEAP16[(($10426)>>1)];
17496       var $10428=(($10427)&65535);
17497       var $10429=(($10423+($10428<<2))|0);
17498       var $10430=$10429;
17499       var $10431=$10430;
17500       var $10432=HEAPF32[(($10431)>>2)];
17501       var $10433=$2;
17502       var $10434=(($10433+64)|0);
17503       var $10435=HEAP32[(($10434)>>2)];
17504       var $10436=$st;
17505       var $10437=(($10436+4)|0);
17506       var $10438=$10437;
17507       var $10439=HEAP16[(($10438)>>1)];
17508       var $10440=(($10439)&65535);
17509       var $10441=(($10435+($10440<<2))|0);
17510       var $10442=$10441;
17511       var $10443=$10442;
17512       var $10444=HEAPF32[(($10443)>>2)];
17513       var $10445=$10432 > $10444;
17514       var $10446=(($10445)&1);
17515       var $10447=(($10446)|0);
17516       var $10448=$2;
17517       var $10449=(($10448+64)|0);
17518       var $10450=HEAP32[(($10449)>>2)];
17519       var $10451=$st;
17520       var $10452=(($10451+6)|0);
17521       var $10453=$10452;
17522       var $10454=HEAP16[(($10453)>>1)];
17523       var $10455=(($10454)&65535);
17524       var $10456=(($10450+($10455<<2))|0);
17525       var $10457=$10456;
17526       var $10458=$10457;
17527       HEAPF32[(($10458)>>2)]=$10447;
17528       __label__ = 487; break;
17529     case 405:
17530       var $10460=$2;
17531       var $10461=(($10460+64)|0);
17532       var $10462=HEAP32[(($10461)>>2)];
17533       var $10463=$st;
17534       var $10464=(($10463+2)|0);
17535       var $10465=$10464;
17536       var $10466=HEAP16[(($10465)>>1)];
17537       var $10467=(($10466)&65535);
17538       var $10468=(($10462+($10467<<2))|0);
17539       var $10469=$10468;
17540       var $10470=$10469;
17541       var $10471=HEAP32[(($10470)>>2)];
17542       var $10472=(($10471)|0) < 0;
17543       if ($10472) { __label__ = 407; break; } else { __label__ = 406; break; }
17544     case 406:
17545       var $10474=$2;
17546       var $10475=(($10474+64)|0);
17547       var $10476=HEAP32[(($10475)>>2)];
17548       var $10477=$st;
17549       var $10478=(($10477+2)|0);
17550       var $10479=$10478;
17551       var $10480=HEAP16[(($10479)>>1)];
17552       var $10481=(($10480)&65535);
17553       var $10482=(($10476+($10481<<2))|0);
17554       var $10483=$10482;
17555       var $10484=$10483;
17556       var $10485=HEAP32[(($10484)>>2)];
17557       var $10486=$2;
17558       var $10487=(($10486+140)|0);
17559       var $10488=HEAP32[(($10487)>>2)];
17560       var $10489=(($10485)|0) >= (($10488)|0);
17561       if ($10489) { __label__ = 407; break; } else { __label__ = 408; break; }
17562     case 407:
17563       var $10491=$2;
17564       var $10492=$2;
17565       var $10493=(($10492)|0);
17566       var $10494=HEAP32[(($10493)>>2)];
17567       _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));
17568       __label__ = 488; break;
17569     case 408:
17570       var $10496=$2;
17571       var $10497=(($10496+64)|0);
17572       var $10498=HEAP32[(($10497)>>2)];
17573       var $10499=$st;
17574       var $10500=(($10499+4)|0);
17575       var $10501=$10500;
17576       var $10502=HEAP16[(($10501)>>1)];
17577       var $10503=(($10502)&65535);
17578       var $10504=(($10498+($10503<<2))|0);
17579       var $10505=$10504;
17580       var $10506=$10505;
17581       var $10507=HEAP32[(($10506)>>2)];
17582       var $10508=$2;
17583       var $10509=(($10508+144)|0);
17584       var $10510=HEAP32[(($10509)>>2)];
17585       var $10511=(($10507)>>>0) >= (($10510)>>>0);
17586       if ($10511) { __label__ = 409; break; } else { __label__ = 410; break; }
17587     case 409:
17588       var $10513=$2;
17589       var $10514=$2;
17590       var $10515=(($10514)|0);
17591       var $10516=HEAP32[(($10515)>>2)];
17592       var $10517=$2;
17593       var $10518=(($10517+64)|0);
17594       var $10519=HEAP32[(($10518)>>2)];
17595       var $10520=$st;
17596       var $10521=(($10520+4)|0);
17597       var $10522=$10521;
17598       var $10523=HEAP16[(($10522)>>1)];
17599       var $10524=(($10523)&65535);
17600       var $10525=(($10519+($10524<<2))|0);
17601       var $10526=$10525;
17602       var $10527=$10526;
17603       var $10528=HEAP32[(($10527)>>2)];
17604       _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));
17605       __label__ = 488; break;
17606     case 410:
17607       var $10530=$2;
17608       var $10531=$2;
17609       var $10532=(($10531+64)|0);
17610       var $10533=HEAP32[(($10532)>>2)];
17611       var $10534=$st;
17612       var $10535=(($10534+2)|0);
17613       var $10536=$10535;
17614       var $10537=HEAP16[(($10536)>>1)];
17615       var $10538=(($10537)&65535);
17616       var $10539=(($10533+($10538<<2))|0);
17617       var $10540=$10539;
17618       var $10541=$10540;
17619       var $10542=HEAP32[(($10541)>>2)];
17620       var $10543=_prog_getedict($10530, $10542);
17621       $ed10=$10543;
17622       var $10544=$ed10;
17623       var $10545=$10544;
17624       var $10546=$2;
17625       var $10547=(($10546+64)|0);
17626       var $10548=HEAP32[(($10547)>>2)];
17627       var $10549=$st;
17628       var $10550=(($10549+4)|0);
17629       var $10551=$10550;
17630       var $10552=HEAP16[(($10551)>>1)];
17631       var $10553=(($10552)&65535);
17632       var $10554=(($10548+($10553<<2))|0);
17633       var $10555=$10554;
17634       var $10556=$10555;
17635       var $10557=HEAP32[(($10556)>>2)];
17636       var $10558=(($10545+($10557<<2))|0);
17637       var $10559=$10558;
17638       var $10560=$10559;
17639       var $10561=HEAP32[(($10560)>>2)];
17640       var $10562=$2;
17641       var $10563=(($10562+64)|0);
17642       var $10564=HEAP32[(($10563)>>2)];
17643       var $10565=$st;
17644       var $10566=(($10565+6)|0);
17645       var $10567=$10566;
17646       var $10568=HEAP16[(($10567)>>1)];
17647       var $10569=(($10568)&65535);
17648       var $10570=(($10564+($10569<<2))|0);
17649       var $10571=$10570;
17650       var $10572=$10571;
17651       HEAP32[(($10572)>>2)]=$10561;
17652       __label__ = 487; break;
17653     case 411:
17654       var $10574=$2;
17655       var $10575=(($10574+64)|0);
17656       var $10576=HEAP32[(($10575)>>2)];
17657       var $10577=$st;
17658       var $10578=(($10577+2)|0);
17659       var $10579=$10578;
17660       var $10580=HEAP16[(($10579)>>1)];
17661       var $10581=(($10580)&65535);
17662       var $10582=(($10576+($10581<<2))|0);
17663       var $10583=$10582;
17664       var $10584=$10583;
17665       var $10585=HEAP32[(($10584)>>2)];
17666       var $10586=(($10585)|0) < 0;
17667       if ($10586) { __label__ = 413; break; } else { __label__ = 412; break; }
17668     case 412:
17669       var $10588=$2;
17670       var $10589=(($10588+64)|0);
17671       var $10590=HEAP32[(($10589)>>2)];
17672       var $10591=$st;
17673       var $10592=(($10591+2)|0);
17674       var $10593=$10592;
17675       var $10594=HEAP16[(($10593)>>1)];
17676       var $10595=(($10594)&65535);
17677       var $10596=(($10590+($10595<<2))|0);
17678       var $10597=$10596;
17679       var $10598=$10597;
17680       var $10599=HEAP32[(($10598)>>2)];
17681       var $10600=$2;
17682       var $10601=(($10600+140)|0);
17683       var $10602=HEAP32[(($10601)>>2)];
17684       var $10603=(($10599)|0) >= (($10602)|0);
17685       if ($10603) { __label__ = 413; break; } else { __label__ = 414; break; }
17686     case 413:
17687       var $10605=$2;
17688       var $10606=$2;
17689       var $10607=(($10606)|0);
17690       var $10608=HEAP32[(($10607)>>2)];
17691       _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));
17692       __label__ = 488; break;
17693     case 414:
17694       var $10610=$2;
17695       var $10611=(($10610+64)|0);
17696       var $10612=HEAP32[(($10611)>>2)];
17697       var $10613=$st;
17698       var $10614=(($10613+4)|0);
17699       var $10615=$10614;
17700       var $10616=HEAP16[(($10615)>>1)];
17701       var $10617=(($10616)&65535);
17702       var $10618=(($10612+($10617<<2))|0);
17703       var $10619=$10618;
17704       var $10620=$10619;
17705       var $10621=HEAP32[(($10620)>>2)];
17706       var $10622=(($10621)|0) < 0;
17707       if ($10622) { __label__ = 416; break; } else { __label__ = 415; break; }
17708     case 415:
17709       var $10624=$2;
17710       var $10625=(($10624+64)|0);
17711       var $10626=HEAP32[(($10625)>>2)];
17712       var $10627=$st;
17713       var $10628=(($10627+4)|0);
17714       var $10629=$10628;
17715       var $10630=HEAP16[(($10629)>>1)];
17716       var $10631=(($10630)&65535);
17717       var $10632=(($10626+($10631<<2))|0);
17718       var $10633=$10632;
17719       var $10634=$10633;
17720       var $10635=HEAP32[(($10634)>>2)];
17721       var $10636=((($10635)+(3))|0);
17722       var $10637=$2;
17723       var $10638=(($10637+144)|0);
17724       var $10639=HEAP32[(($10638)>>2)];
17725       var $10640=(($10636)>>>0) > (($10639)>>>0);
17726       if ($10640) { __label__ = 416; break; } else { __label__ = 417; break; }
17727     case 416:
17728       var $10642=$2;
17729       var $10643=$2;
17730       var $10644=(($10643)|0);
17731       var $10645=HEAP32[(($10644)>>2)];
17732       var $10646=$2;
17733       var $10647=(($10646+64)|0);
17734       var $10648=HEAP32[(($10647)>>2)];
17735       var $10649=$st;
17736       var $10650=(($10649+4)|0);
17737       var $10651=$10650;
17738       var $10652=HEAP16[(($10651)>>1)];
17739       var $10653=(($10652)&65535);
17740       var $10654=(($10648+($10653<<2))|0);
17741       var $10655=$10654;
17742       var $10656=$10655;
17743       var $10657=HEAP32[(($10656)>>2)];
17744       var $10658=((($10657)+(2))|0);
17745       _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));
17746       __label__ = 488; break;
17747     case 417:
17748       var $10660=$2;
17749       var $10661=$2;
17750       var $10662=(($10661+64)|0);
17751       var $10663=HEAP32[(($10662)>>2)];
17752       var $10664=$st;
17753       var $10665=(($10664+2)|0);
17754       var $10666=$10665;
17755       var $10667=HEAP16[(($10666)>>1)];
17756       var $10668=(($10667)&65535);
17757       var $10669=(($10663+($10668<<2))|0);
17758       var $10670=$10669;
17759       var $10671=$10670;
17760       var $10672=HEAP32[(($10671)>>2)];
17761       var $10673=_prog_getedict($10660, $10672);
17762       $ed10=$10673;
17763       var $10674=$ed10;
17764       var $10675=$10674;
17765       var $10676=$2;
17766       var $10677=(($10676+64)|0);
17767       var $10678=HEAP32[(($10677)>>2)];
17768       var $10679=$st;
17769       var $10680=(($10679+4)|0);
17770       var $10681=$10680;
17771       var $10682=HEAP16[(($10681)>>1)];
17772       var $10683=(($10682)&65535);
17773       var $10684=(($10678+($10683<<2))|0);
17774       var $10685=$10684;
17775       var $10686=$10685;
17776       var $10687=HEAP32[(($10686)>>2)];
17777       var $10688=(($10675+($10687<<2))|0);
17778       var $10689=$10688;
17779       var $10690=$10689;
17780       var $10691=(($10690)|0);
17781       var $10692=HEAP32[(($10691)>>2)];
17782       var $10693=$2;
17783       var $10694=(($10693+64)|0);
17784       var $10695=HEAP32[(($10694)>>2)];
17785       var $10696=$st;
17786       var $10697=(($10696+6)|0);
17787       var $10698=$10697;
17788       var $10699=HEAP16[(($10698)>>1)];
17789       var $10700=(($10699)&65535);
17790       var $10701=(($10695+($10700<<2))|0);
17791       var $10702=$10701;
17792       var $10703=$10702;
17793       var $10704=(($10703)|0);
17794       HEAP32[(($10704)>>2)]=$10692;
17795       var $10705=$ed10;
17796       var $10706=$10705;
17797       var $10707=$2;
17798       var $10708=(($10707+64)|0);
17799       var $10709=HEAP32[(($10708)>>2)];
17800       var $10710=$st;
17801       var $10711=(($10710+4)|0);
17802       var $10712=$10711;
17803       var $10713=HEAP16[(($10712)>>1)];
17804       var $10714=(($10713)&65535);
17805       var $10715=(($10709+($10714<<2))|0);
17806       var $10716=$10715;
17807       var $10717=$10716;
17808       var $10718=HEAP32[(($10717)>>2)];
17809       var $10719=(($10706+($10718<<2))|0);
17810       var $10720=$10719;
17811       var $10721=$10720;
17812       var $10722=(($10721+4)|0);
17813       var $10723=HEAP32[(($10722)>>2)];
17814       var $10724=$2;
17815       var $10725=(($10724+64)|0);
17816       var $10726=HEAP32[(($10725)>>2)];
17817       var $10727=$st;
17818       var $10728=(($10727+6)|0);
17819       var $10729=$10728;
17820       var $10730=HEAP16[(($10729)>>1)];
17821       var $10731=(($10730)&65535);
17822       var $10732=(($10726+($10731<<2))|0);
17823       var $10733=$10732;
17824       var $10734=$10733;
17825       var $10735=(($10734+4)|0);
17826       HEAP32[(($10735)>>2)]=$10723;
17827       var $10736=$ed10;
17828       var $10737=$10736;
17829       var $10738=$2;
17830       var $10739=(($10738+64)|0);
17831       var $10740=HEAP32[(($10739)>>2)];
17832       var $10741=$st;
17833       var $10742=(($10741+4)|0);
17834       var $10743=$10742;
17835       var $10744=HEAP16[(($10743)>>1)];
17836       var $10745=(($10744)&65535);
17837       var $10746=(($10740+($10745<<2))|0);
17838       var $10747=$10746;
17839       var $10748=$10747;
17840       var $10749=HEAP32[(($10748)>>2)];
17841       var $10750=(($10737+($10749<<2))|0);
17842       var $10751=$10750;
17843       var $10752=$10751;
17844       var $10753=(($10752+8)|0);
17845       var $10754=HEAP32[(($10753)>>2)];
17846       var $10755=$2;
17847       var $10756=(($10755+64)|0);
17848       var $10757=HEAP32[(($10756)>>2)];
17849       var $10758=$st;
17850       var $10759=(($10758+6)|0);
17851       var $10760=$10759;
17852       var $10761=HEAP16[(($10760)>>1)];
17853       var $10762=(($10761)&65535);
17854       var $10763=(($10757+($10762<<2))|0);
17855       var $10764=$10763;
17856       var $10765=$10764;
17857       var $10766=(($10765+8)|0);
17858       HEAP32[(($10766)>>2)]=$10754;
17859       __label__ = 487; break;
17860     case 418:
17861       var $10768=$2;
17862       var $10769=(($10768+64)|0);
17863       var $10770=HEAP32[(($10769)>>2)];
17864       var $10771=$st;
17865       var $10772=(($10771+2)|0);
17866       var $10773=$10772;
17867       var $10774=HEAP16[(($10773)>>1)];
17868       var $10775=(($10774)&65535);
17869       var $10776=(($10770+($10775<<2))|0);
17870       var $10777=$10776;
17871       var $10778=$10777;
17872       var $10779=HEAP32[(($10778)>>2)];
17873       var $10780=(($10779)|0) < 0;
17874       if ($10780) { __label__ = 420; break; } else { __label__ = 419; break; }
17875     case 419:
17876       var $10782=$2;
17877       var $10783=(($10782+64)|0);
17878       var $10784=HEAP32[(($10783)>>2)];
17879       var $10785=$st;
17880       var $10786=(($10785+2)|0);
17881       var $10787=$10786;
17882       var $10788=HEAP16[(($10787)>>1)];
17883       var $10789=(($10788)&65535);
17884       var $10790=(($10784+($10789<<2))|0);
17885       var $10791=$10790;
17886       var $10792=$10791;
17887       var $10793=HEAP32[(($10792)>>2)];
17888       var $10794=$2;
17889       var $10795=(($10794+140)|0);
17890       var $10796=HEAP32[(($10795)>>2)];
17891       var $10797=(($10793)|0) >= (($10796)|0);
17892       if ($10797) { __label__ = 420; break; } else { __label__ = 421; break; }
17893     case 420:
17894       var $10799=$2;
17895       var $10800=$2;
17896       var $10801=(($10800)|0);
17897       var $10802=HEAP32[(($10801)>>2)];
17898       var $10803=$2;
17899       var $10804=(($10803+64)|0);
17900       var $10805=HEAP32[(($10804)>>2)];
17901       var $10806=$st;
17902       var $10807=(($10806+2)|0);
17903       var $10808=$10807;
17904       var $10809=HEAP16[(($10808)>>1)];
17905       var $10810=(($10809)&65535);
17906       var $10811=(($10805+($10810<<2))|0);
17907       var $10812=$10811;
17908       var $10813=$10812;
17909       var $10814=HEAP32[(($10813)>>2)];
17910       _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));
17911       __label__ = 488; break;
17912     case 421:
17913       var $10816=$2;
17914       var $10817=(($10816+64)|0);
17915       var $10818=HEAP32[(($10817)>>2)];
17916       var $10819=$st;
17917       var $10820=(($10819+4)|0);
17918       var $10821=$10820;
17919       var $10822=HEAP16[(($10821)>>1)];
17920       var $10823=(($10822)&65535);
17921       var $10824=(($10818+($10823<<2))|0);
17922       var $10825=$10824;
17923       var $10826=$10825;
17924       var $10827=HEAP32[(($10826)>>2)];
17925       var $10828=$2;
17926       var $10829=(($10828+144)|0);
17927       var $10830=HEAP32[(($10829)>>2)];
17928       var $10831=(($10827)>>>0) >= (($10830)>>>0);
17929       if ($10831) { __label__ = 422; break; } else { __label__ = 423; break; }
17930     case 422:
17931       var $10833=$2;
17932       var $10834=$2;
17933       var $10835=(($10834)|0);
17934       var $10836=HEAP32[(($10835)>>2)];
17935       var $10837=$2;
17936       var $10838=(($10837+64)|0);
17937       var $10839=HEAP32[(($10838)>>2)];
17938       var $10840=$st;
17939       var $10841=(($10840+4)|0);
17940       var $10842=$10841;
17941       var $10843=HEAP16[(($10842)>>1)];
17942       var $10844=(($10843)&65535);
17943       var $10845=(($10839+($10844<<2))|0);
17944       var $10846=$10845;
17945       var $10847=$10846;
17946       var $10848=HEAP32[(($10847)>>2)];
17947       _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));
17948       __label__ = 488; break;
17949     case 423:
17950       var $10850=$2;
17951       var $10851=$2;
17952       var $10852=(($10851+64)|0);
17953       var $10853=HEAP32[(($10852)>>2)];
17954       var $10854=$st;
17955       var $10855=(($10854+2)|0);
17956       var $10856=$10855;
17957       var $10857=HEAP16[(($10856)>>1)];
17958       var $10858=(($10857)&65535);
17959       var $10859=(($10853+($10858<<2))|0);
17960       var $10860=$10859;
17961       var $10861=$10860;
17962       var $10862=HEAP32[(($10861)>>2)];
17963       var $10863=_prog_getedict($10850, $10862);
17964       $ed10=$10863;
17965       var $10864=$ed10;
17966       var $10865=$10864;
17967       var $10866=$2;
17968       var $10867=(($10866+76)|0);
17969       var $10868=HEAP32[(($10867)>>2)];
17970       var $10869=$10865;
17971       var $10870=$10868;
17972       var $10871=((($10869)-($10870))|0);
17973       var $10872=((((($10871)|0))/(4))&-1);
17974       var $10873=$2;
17975       var $10874=(($10873+64)|0);
17976       var $10875=HEAP32[(($10874)>>2)];
17977       var $10876=$st;
17978       var $10877=(($10876+6)|0);
17979       var $10878=$10877;
17980       var $10879=HEAP16[(($10878)>>1)];
17981       var $10880=(($10879)&65535);
17982       var $10881=(($10875+($10880<<2))|0);
17983       var $10882=$10881;
17984       var $10883=$10882;
17985       HEAP32[(($10883)>>2)]=$10872;
17986       var $10884=$2;
17987       var $10885=(($10884+64)|0);
17988       var $10886=HEAP32[(($10885)>>2)];
17989       var $10887=$st;
17990       var $10888=(($10887+4)|0);
17991       var $10889=$10888;
17992       var $10890=HEAP16[(($10889)>>1)];
17993       var $10891=(($10890)&65535);
17994       var $10892=(($10886+($10891<<2))|0);
17995       var $10893=$10892;
17996       var $10894=$10893;
17997       var $10895=HEAP32[(($10894)>>2)];
17998       var $10896=$2;
17999       var $10897=(($10896+64)|0);
18000       var $10898=HEAP32[(($10897)>>2)];
18001       var $10899=$st;
18002       var $10900=(($10899+6)|0);
18003       var $10901=$10900;
18004       var $10902=HEAP16[(($10901)>>1)];
18005       var $10903=(($10902)&65535);
18006       var $10904=(($10898+($10903<<2))|0);
18007       var $10905=$10904;
18008       var $10906=$10905;
18009       var $10907=HEAP32[(($10906)>>2)];
18010       var $10908=((($10907)+($10895))|0);
18011       HEAP32[(($10906)>>2)]=$10908;
18012       __label__ = 487; break;
18013     case 424:
18014       var $10910=$2;
18015       var $10911=(($10910+64)|0);
18016       var $10912=HEAP32[(($10911)>>2)];
18017       var $10913=$st;
18018       var $10914=(($10913+2)|0);
18019       var $10915=$10914;
18020       var $10916=HEAP16[(($10915)>>1)];
18021       var $10917=(($10916)&65535);
18022       var $10918=(($10912+($10917<<2))|0);
18023       var $10919=$10918;
18024       var $10920=$10919;
18025       var $10921=HEAP32[(($10920)>>2)];
18026       var $10922=$2;
18027       var $10923=(($10922+64)|0);
18028       var $10924=HEAP32[(($10923)>>2)];
18029       var $10925=$st;
18030       var $10926=(($10925+4)|0);
18031       var $10927=$10926;
18032       var $10928=HEAP16[(($10927)>>1)];
18033       var $10929=(($10928)&65535);
18034       var $10930=(($10924+($10929<<2))|0);
18035       var $10931=$10930;
18036       var $10932=$10931;
18037       HEAP32[(($10932)>>2)]=$10921;
18038       __label__ = 487; break;
18039     case 425:
18040       var $10934=$2;
18041       var $10935=(($10934+64)|0);
18042       var $10936=HEAP32[(($10935)>>2)];
18043       var $10937=$st;
18044       var $10938=(($10937+2)|0);
18045       var $10939=$10938;
18046       var $10940=HEAP16[(($10939)>>1)];
18047       var $10941=(($10940)&65535);
18048       var $10942=(($10936+($10941<<2))|0);
18049       var $10943=$10942;
18050       var $10944=$10943;
18051       var $10945=(($10944)|0);
18052       var $10946=HEAP32[(($10945)>>2)];
18053       var $10947=$2;
18054       var $10948=(($10947+64)|0);
18055       var $10949=HEAP32[(($10948)>>2)];
18056       var $10950=$st;
18057       var $10951=(($10950+4)|0);
18058       var $10952=$10951;
18059       var $10953=HEAP16[(($10952)>>1)];
18060       var $10954=(($10953)&65535);
18061       var $10955=(($10949+($10954<<2))|0);
18062       var $10956=$10955;
18063       var $10957=$10956;
18064       var $10958=(($10957)|0);
18065       HEAP32[(($10958)>>2)]=$10946;
18066       var $10959=$2;
18067       var $10960=(($10959+64)|0);
18068       var $10961=HEAP32[(($10960)>>2)];
18069       var $10962=$st;
18070       var $10963=(($10962+2)|0);
18071       var $10964=$10963;
18072       var $10965=HEAP16[(($10964)>>1)];
18073       var $10966=(($10965)&65535);
18074       var $10967=(($10961+($10966<<2))|0);
18075       var $10968=$10967;
18076       var $10969=$10968;
18077       var $10970=(($10969+4)|0);
18078       var $10971=HEAP32[(($10970)>>2)];
18079       var $10972=$2;
18080       var $10973=(($10972+64)|0);
18081       var $10974=HEAP32[(($10973)>>2)];
18082       var $10975=$st;
18083       var $10976=(($10975+4)|0);
18084       var $10977=$10976;
18085       var $10978=HEAP16[(($10977)>>1)];
18086       var $10979=(($10978)&65535);
18087       var $10980=(($10974+($10979<<2))|0);
18088       var $10981=$10980;
18089       var $10982=$10981;
18090       var $10983=(($10982+4)|0);
18091       HEAP32[(($10983)>>2)]=$10971;
18092       var $10984=$2;
18093       var $10985=(($10984+64)|0);
18094       var $10986=HEAP32[(($10985)>>2)];
18095       var $10987=$st;
18096       var $10988=(($10987+2)|0);
18097       var $10989=$10988;
18098       var $10990=HEAP16[(($10989)>>1)];
18099       var $10991=(($10990)&65535);
18100       var $10992=(($10986+($10991<<2))|0);
18101       var $10993=$10992;
18102       var $10994=$10993;
18103       var $10995=(($10994+8)|0);
18104       var $10996=HEAP32[(($10995)>>2)];
18105       var $10997=$2;
18106       var $10998=(($10997+64)|0);
18107       var $10999=HEAP32[(($10998)>>2)];
18108       var $11000=$st;
18109       var $11001=(($11000+4)|0);
18110       var $11002=$11001;
18111       var $11003=HEAP16[(($11002)>>1)];
18112       var $11004=(($11003)&65535);
18113       var $11005=(($10999+($11004<<2))|0);
18114       var $11006=$11005;
18115       var $11007=$11006;
18116       var $11008=(($11007+8)|0);
18117       HEAP32[(($11008)>>2)]=$10996;
18118       __label__ = 487; break;
18119     case 426:
18120       var $11010=$2;
18121       var $11011=(($11010+64)|0);
18122       var $11012=HEAP32[(($11011)>>2)];
18123       var $11013=$st;
18124       var $11014=(($11013+4)|0);
18125       var $11015=$11014;
18126       var $11016=HEAP16[(($11015)>>1)];
18127       var $11017=(($11016)&65535);
18128       var $11018=(($11012+($11017<<2))|0);
18129       var $11019=$11018;
18130       var $11020=$11019;
18131       var $11021=HEAP32[(($11020)>>2)];
18132       var $11022=(($11021)|0) < 0;
18133       if ($11022) { __label__ = 428; break; } else { __label__ = 427; break; }
18134     case 427:
18135       var $11024=$2;
18136       var $11025=(($11024+64)|0);
18137       var $11026=HEAP32[(($11025)>>2)];
18138       var $11027=$st;
18139       var $11028=(($11027+4)|0);
18140       var $11029=$11028;
18141       var $11030=HEAP16[(($11029)>>1)];
18142       var $11031=(($11030)&65535);
18143       var $11032=(($11026+($11031<<2))|0);
18144       var $11033=$11032;
18145       var $11034=$11033;
18146       var $11035=HEAP32[(($11034)>>2)];
18147       var $11036=$2;
18148       var $11037=(($11036+80)|0);
18149       var $11038=HEAP32[(($11037)>>2)];
18150       var $11039=(($11035)>>>0) >= (($11038)>>>0);
18151       if ($11039) { __label__ = 428; break; } else { __label__ = 429; break; }
18152     case 428:
18153       var $11041=$2;
18154       var $11042=$2;
18155       var $11043=(($11042)|0);
18156       var $11044=HEAP32[(($11043)>>2)];
18157       var $11045=$2;
18158       var $11046=(($11045+64)|0);
18159       var $11047=HEAP32[(($11046)>>2)];
18160       var $11048=$st;
18161       var $11049=(($11048+4)|0);
18162       var $11050=$11049;
18163       var $11051=HEAP16[(($11050)>>1)];
18164       var $11052=(($11051)&65535);
18165       var $11053=(($11047+($11052<<2))|0);
18166       var $11054=$11053;
18167       var $11055=$11054;
18168       var $11056=HEAP32[(($11055)>>2)];
18169       _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));
18170       __label__ = 488; break;
18171     case 429:
18172       var $11058=$2;
18173       var $11059=(($11058+64)|0);
18174       var $11060=HEAP32[(($11059)>>2)];
18175       var $11061=$st;
18176       var $11062=(($11061+4)|0);
18177       var $11063=$11062;
18178       var $11064=HEAP16[(($11063)>>1)];
18179       var $11065=(($11064)&65535);
18180       var $11066=(($11060+($11065<<2))|0);
18181       var $11067=$11066;
18182       var $11068=$11067;
18183       var $11069=HEAP32[(($11068)>>2)];
18184       var $11070=$2;
18185       var $11071=(($11070+144)|0);
18186       var $11072=HEAP32[(($11071)>>2)];
18187       var $11073=(($11069)>>>0) < (($11072)>>>0);
18188       if ($11073) { __label__ = 430; break; } else { __label__ = 432; break; }
18189     case 430:
18190       var $11075=$2;
18191       var $11076=(($11075+148)|0);
18192       var $11077=HEAP8[($11076)];
18193       var $11078=(($11077) & 1);
18194       if ($11078) { __label__ = 432; break; } else { __label__ = 431; break; }
18195     case 431:
18196       var $11080=$2;
18197       var $11081=$2;
18198       var $11082=(($11081)|0);
18199       var $11083=HEAP32[(($11082)>>2)];
18200       var $11084=$2;
18201       var $11085=$2;
18202       var $11086=$2;
18203       var $11087=(($11086+64)|0);
18204       var $11088=HEAP32[(($11087)>>2)];
18205       var $11089=$st;
18206       var $11090=(($11089+4)|0);
18207       var $11091=$11090;
18208       var $11092=HEAP16[(($11091)>>1)];
18209       var $11093=(($11092)&65535);
18210       var $11094=(($11088+($11093<<2))|0);
18211       var $11095=$11094;
18212       var $11096=$11095;
18213       var $11097=HEAP32[(($11096)>>2)];
18214       var $11098=_prog_entfield($11085, $11097);
18215       var $11099=(($11098+4)|0);
18216       var $11100=HEAP32[(($11099)>>2)];
18217       var $11101=_prog_getstring($11084, $11100);
18218       var $11102=$2;
18219       var $11103=(($11102+64)|0);
18220       var $11104=HEAP32[(($11103)>>2)];
18221       var $11105=$st;
18222       var $11106=(($11105+4)|0);
18223       var $11107=$11106;
18224       var $11108=HEAP16[(($11107)>>1)];
18225       var $11109=(($11108)&65535);
18226       var $11110=(($11104+($11109<<2))|0);
18227       var $11111=$11110;
18228       var $11112=$11111;
18229       var $11113=HEAP32[(($11112)>>2)];
18230       _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));
18231       __label__ = 432; break;
18232     case 432:
18233       var $11115=$2;
18234       var $11116=(($11115+76)|0);
18235       var $11117=HEAP32[(($11116)>>2)];
18236       var $11118=$2;
18237       var $11119=(($11118+64)|0);
18238       var $11120=HEAP32[(($11119)>>2)];
18239       var $11121=$st;
18240       var $11122=(($11121+4)|0);
18241       var $11123=$11122;
18242       var $11124=HEAP16[(($11123)>>1)];
18243       var $11125=(($11124)&65535);
18244       var $11126=(($11120+($11125<<2))|0);
18245       var $11127=$11126;
18246       var $11128=$11127;
18247       var $11129=HEAP32[(($11128)>>2)];
18248       var $11130=(($11117+($11129<<2))|0);
18249       var $11131=$11130;
18250       $ptr11=$11131;
18251       var $11132=$2;
18252       var $11133=(($11132+64)|0);
18253       var $11134=HEAP32[(($11133)>>2)];
18254       var $11135=$st;
18255       var $11136=(($11135+2)|0);
18256       var $11137=$11136;
18257       var $11138=HEAP16[(($11137)>>1)];
18258       var $11139=(($11138)&65535);
18259       var $11140=(($11134+($11139<<2))|0);
18260       var $11141=$11140;
18261       var $11142=$11141;
18262       var $11143=HEAP32[(($11142)>>2)];
18263       var $11144=$ptr11;
18264       var $11145=$11144;
18265       HEAP32[(($11145)>>2)]=$11143;
18266       __label__ = 487; break;
18267     case 433:
18268       var $11147=$2;
18269       var $11148=(($11147+64)|0);
18270       var $11149=HEAP32[(($11148)>>2)];
18271       var $11150=$st;
18272       var $11151=(($11150+4)|0);
18273       var $11152=$11151;
18274       var $11153=HEAP16[(($11152)>>1)];
18275       var $11154=(($11153)&65535);
18276       var $11155=(($11149+($11154<<2))|0);
18277       var $11156=$11155;
18278       var $11157=$11156;
18279       var $11158=HEAP32[(($11157)>>2)];
18280       var $11159=(($11158)|0) < 0;
18281       if ($11159) { __label__ = 435; break; } else { __label__ = 434; break; }
18282     case 434:
18283       var $11161=$2;
18284       var $11162=(($11161+64)|0);
18285       var $11163=HEAP32[(($11162)>>2)];
18286       var $11164=$st;
18287       var $11165=(($11164+4)|0);
18288       var $11166=$11165;
18289       var $11167=HEAP16[(($11166)>>1)];
18290       var $11168=(($11167)&65535);
18291       var $11169=(($11163+($11168<<2))|0);
18292       var $11170=$11169;
18293       var $11171=$11170;
18294       var $11172=HEAP32[(($11171)>>2)];
18295       var $11173=((($11172)+(2))|0);
18296       var $11174=$2;
18297       var $11175=(($11174+80)|0);
18298       var $11176=HEAP32[(($11175)>>2)];
18299       var $11177=(($11173)>>>0) >= (($11176)>>>0);
18300       if ($11177) { __label__ = 435; break; } else { __label__ = 436; break; }
18301     case 435:
18302       var $11179=$2;
18303       var $11180=$2;
18304       var $11181=(($11180)|0);
18305       var $11182=HEAP32[(($11181)>>2)];
18306       var $11183=$2;
18307       var $11184=(($11183+64)|0);
18308       var $11185=HEAP32[(($11184)>>2)];
18309       var $11186=$st;
18310       var $11187=(($11186+4)|0);
18311       var $11188=$11187;
18312       var $11189=HEAP16[(($11188)>>1)];
18313       var $11190=(($11189)&65535);
18314       var $11191=(($11185+($11190<<2))|0);
18315       var $11192=$11191;
18316       var $11193=$11192;
18317       var $11194=HEAP32[(($11193)>>2)];
18318       _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));
18319       __label__ = 488; break;
18320     case 436:
18321       var $11196=$2;
18322       var $11197=(($11196+64)|0);
18323       var $11198=HEAP32[(($11197)>>2)];
18324       var $11199=$st;
18325       var $11200=(($11199+4)|0);
18326       var $11201=$11200;
18327       var $11202=HEAP16[(($11201)>>1)];
18328       var $11203=(($11202)&65535);
18329       var $11204=(($11198+($11203<<2))|0);
18330       var $11205=$11204;
18331       var $11206=$11205;
18332       var $11207=HEAP32[(($11206)>>2)];
18333       var $11208=$2;
18334       var $11209=(($11208+144)|0);
18335       var $11210=HEAP32[(($11209)>>2)];
18336       var $11211=(($11207)>>>0) < (($11210)>>>0);
18337       if ($11211) { __label__ = 437; break; } else { __label__ = 439; break; }
18338     case 437:
18339       var $11213=$2;
18340       var $11214=(($11213+148)|0);
18341       var $11215=HEAP8[($11214)];
18342       var $11216=(($11215) & 1);
18343       if ($11216) { __label__ = 439; break; } else { __label__ = 438; break; }
18344     case 438:
18345       var $11218=$2;
18346       var $11219=$2;
18347       var $11220=(($11219)|0);
18348       var $11221=HEAP32[(($11220)>>2)];
18349       var $11222=$2;
18350       var $11223=$2;
18351       var $11224=$2;
18352       var $11225=(($11224+64)|0);
18353       var $11226=HEAP32[(($11225)>>2)];
18354       var $11227=$st;
18355       var $11228=(($11227+4)|0);
18356       var $11229=$11228;
18357       var $11230=HEAP16[(($11229)>>1)];
18358       var $11231=(($11230)&65535);
18359       var $11232=(($11226+($11231<<2))|0);
18360       var $11233=$11232;
18361       var $11234=$11233;
18362       var $11235=HEAP32[(($11234)>>2)];
18363       var $11236=_prog_entfield($11223, $11235);
18364       var $11237=(($11236+4)|0);
18365       var $11238=HEAP32[(($11237)>>2)];
18366       var $11239=_prog_getstring($11222, $11238);
18367       var $11240=$2;
18368       var $11241=(($11240+64)|0);
18369       var $11242=HEAP32[(($11241)>>2)];
18370       var $11243=$st;
18371       var $11244=(($11243+4)|0);
18372       var $11245=$11244;
18373       var $11246=HEAP16[(($11245)>>1)];
18374       var $11247=(($11246)&65535);
18375       var $11248=(($11242+($11247<<2))|0);
18376       var $11249=$11248;
18377       var $11250=$11249;
18378       var $11251=HEAP32[(($11250)>>2)];
18379       _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));
18380       __label__ = 439; break;
18381     case 439:
18382       var $11253=$2;
18383       var $11254=(($11253+76)|0);
18384       var $11255=HEAP32[(($11254)>>2)];
18385       var $11256=$2;
18386       var $11257=(($11256+64)|0);
18387       var $11258=HEAP32[(($11257)>>2)];
18388       var $11259=$st;
18389       var $11260=(($11259+4)|0);
18390       var $11261=$11260;
18391       var $11262=HEAP16[(($11261)>>1)];
18392       var $11263=(($11262)&65535);
18393       var $11264=(($11258+($11263<<2))|0);
18394       var $11265=$11264;
18395       var $11266=$11265;
18396       var $11267=HEAP32[(($11266)>>2)];
18397       var $11268=(($11255+($11267<<2))|0);
18398       var $11269=$11268;
18399       $ptr11=$11269;
18400       var $11270=$2;
18401       var $11271=(($11270+64)|0);
18402       var $11272=HEAP32[(($11271)>>2)];
18403       var $11273=$st;
18404       var $11274=(($11273+2)|0);
18405       var $11275=$11274;
18406       var $11276=HEAP16[(($11275)>>1)];
18407       var $11277=(($11276)&65535);
18408       var $11278=(($11272+($11277<<2))|0);
18409       var $11279=$11278;
18410       var $11280=$11279;
18411       var $11281=(($11280)|0);
18412       var $11282=HEAP32[(($11281)>>2)];
18413       var $11283=$ptr11;
18414       var $11284=$11283;
18415       var $11285=(($11284)|0);
18416       HEAP32[(($11285)>>2)]=$11282;
18417       var $11286=$2;
18418       var $11287=(($11286+64)|0);
18419       var $11288=HEAP32[(($11287)>>2)];
18420       var $11289=$st;
18421       var $11290=(($11289+2)|0);
18422       var $11291=$11290;
18423       var $11292=HEAP16[(($11291)>>1)];
18424       var $11293=(($11292)&65535);
18425       var $11294=(($11288+($11293<<2))|0);
18426       var $11295=$11294;
18427       var $11296=$11295;
18428       var $11297=(($11296+4)|0);
18429       var $11298=HEAP32[(($11297)>>2)];
18430       var $11299=$ptr11;
18431       var $11300=$11299;
18432       var $11301=(($11300+4)|0);
18433       HEAP32[(($11301)>>2)]=$11298;
18434       var $11302=$2;
18435       var $11303=(($11302+64)|0);
18436       var $11304=HEAP32[(($11303)>>2)];
18437       var $11305=$st;
18438       var $11306=(($11305+2)|0);
18439       var $11307=$11306;
18440       var $11308=HEAP16[(($11307)>>1)];
18441       var $11309=(($11308)&65535);
18442       var $11310=(($11304+($11309<<2))|0);
18443       var $11311=$11310;
18444       var $11312=$11311;
18445       var $11313=(($11312+8)|0);
18446       var $11314=HEAP32[(($11313)>>2)];
18447       var $11315=$ptr11;
18448       var $11316=$11315;
18449       var $11317=(($11316+8)|0);
18450       HEAP32[(($11317)>>2)]=$11314;
18451       __label__ = 487; break;
18452     case 440:
18453       var $11319=$2;
18454       var $11320=(($11319+64)|0);
18455       var $11321=HEAP32[(($11320)>>2)];
18456       var $11322=$st;
18457       var $11323=(($11322+2)|0);
18458       var $11324=$11323;
18459       var $11325=HEAP16[(($11324)>>1)];
18460       var $11326=(($11325)&65535);
18461       var $11327=(($11321+($11326<<2))|0);
18462       var $11328=$11327;
18463       var $11329=$11328;
18464       var $11330=HEAP32[(($11329)>>2)];
18465       var $11331=$11330 & 2147483647;
18466       var $11332=(($11331)|0)!=0;
18467       var $11333=$11332 ^ 1;
18468       var $11334=(($11333)&1);
18469       var $11335=(($11334)|0);
18470       var $11336=$2;
18471       var $11337=(($11336+64)|0);
18472       var $11338=HEAP32[(($11337)>>2)];
18473       var $11339=$st;
18474       var $11340=(($11339+6)|0);
18475       var $11341=$11340;
18476       var $11342=HEAP16[(($11341)>>1)];
18477       var $11343=(($11342)&65535);
18478       var $11344=(($11338+($11343<<2))|0);
18479       var $11345=$11344;
18480       var $11346=$11345;
18481       HEAPF32[(($11346)>>2)]=$11335;
18482       __label__ = 487; break;
18483     case 441:
18484       var $11348=$2;
18485       var $11349=(($11348+64)|0);
18486       var $11350=HEAP32[(($11349)>>2)];
18487       var $11351=$st;
18488       var $11352=(($11351+2)|0);
18489       var $11353=$11352;
18490       var $11354=HEAP16[(($11353)>>1)];
18491       var $11355=(($11354)&65535);
18492       var $11356=(($11350+($11355<<2))|0);
18493       var $11357=$11356;
18494       var $11358=$11357;
18495       var $11359=(($11358)|0);
18496       var $11360=HEAPF32[(($11359)>>2)];
18497       var $11361=$11360 != 0;
18498       if ($11361) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 442; break; }
18499     case 442:
18500       var $11363=$2;
18501       var $11364=(($11363+64)|0);
18502       var $11365=HEAP32[(($11364)>>2)];
18503       var $11366=$st;
18504       var $11367=(($11366+2)|0);
18505       var $11368=$11367;
18506       var $11369=HEAP16[(($11368)>>1)];
18507       var $11370=(($11369)&65535);
18508       var $11371=(($11365+($11370<<2))|0);
18509       var $11372=$11371;
18510       var $11373=$11372;
18511       var $11374=(($11373+4)|0);
18512       var $11375=HEAPF32[(($11374)>>2)];
18513       var $11376=$11375 != 0;
18514       if ($11376) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 443; break; }
18515     case 443:
18516       var $11378=$2;
18517       var $11379=(($11378+64)|0);
18518       var $11380=HEAP32[(($11379)>>2)];
18519       var $11381=$st;
18520       var $11382=(($11381+2)|0);
18521       var $11383=$11382;
18522       var $11384=HEAP16[(($11383)>>1)];
18523       var $11385=(($11384)&65535);
18524       var $11386=(($11380+($11385<<2))|0);
18525       var $11387=$11386;
18526       var $11388=$11387;
18527       var $11389=(($11388+8)|0);
18528       var $11390=HEAPF32[(($11389)>>2)];
18529       var $11391=$11390 != 0;
18530       var $11392=$11391 ^ 1;
18531       var $11394 = $11392;__label__ = 444; break;
18532     case 444:
18533       var $11394;
18534       var $11395=(($11394)&1);
18535       var $11396=(($11395)|0);
18536       var $11397=$2;
18537       var $11398=(($11397+64)|0);
18538       var $11399=HEAP32[(($11398)>>2)];
18539       var $11400=$st;
18540       var $11401=(($11400+6)|0);
18541       var $11402=$11401;
18542       var $11403=HEAP16[(($11402)>>1)];
18543       var $11404=(($11403)&65535);
18544       var $11405=(($11399+($11404<<2))|0);
18545       var $11406=$11405;
18546       var $11407=$11406;
18547       HEAPF32[(($11407)>>2)]=$11396;
18548       __label__ = 487; break;
18549     case 445:
18550       var $11409=$2;
18551       var $11410=(($11409+64)|0);
18552       var $11411=HEAP32[(($11410)>>2)];
18553       var $11412=$st;
18554       var $11413=(($11412+2)|0);
18555       var $11414=$11413;
18556       var $11415=HEAP16[(($11414)>>1)];
18557       var $11416=(($11415)&65535);
18558       var $11417=(($11411+($11416<<2))|0);
18559       var $11418=$11417;
18560       var $11419=$11418;
18561       var $11420=HEAP32[(($11419)>>2)];
18562       var $11421=(($11420)|0)!=0;
18563       if ($11421) { __label__ = 446; break; } else { var $11441 = 1;__label__ = 447; break; }
18564     case 446:
18565       var $11423=$2;
18566       var $11424=$2;
18567       var $11425=(($11424+64)|0);
18568       var $11426=HEAP32[(($11425)>>2)];
18569       var $11427=$st;
18570       var $11428=(($11427+2)|0);
18571       var $11429=$11428;
18572       var $11430=HEAP16[(($11429)>>1)];
18573       var $11431=(($11430)&65535);
18574       var $11432=(($11426+($11431<<2))|0);
18575       var $11433=$11432;
18576       var $11434=$11433;
18577       var $11435=HEAP32[(($11434)>>2)];
18578       var $11436=_prog_getstring($11423, $11435);
18579       var $11437=HEAP8[($11436)];
18580       var $11438=(($11437 << 24) >> 24)!=0;
18581       var $11439=$11438 ^ 1;
18582       var $11441 = $11439;__label__ = 447; break;
18583     case 447:
18584       var $11441;
18585       var $11442=(($11441)&1);
18586       var $11443=(($11442)|0);
18587       var $11444=$2;
18588       var $11445=(($11444+64)|0);
18589       var $11446=HEAP32[(($11445)>>2)];
18590       var $11447=$st;
18591       var $11448=(($11447+6)|0);
18592       var $11449=$11448;
18593       var $11450=HEAP16[(($11449)>>1)];
18594       var $11451=(($11450)&65535);
18595       var $11452=(($11446+($11451<<2))|0);
18596       var $11453=$11452;
18597       var $11454=$11453;
18598       HEAPF32[(($11454)>>2)]=$11443;
18599       __label__ = 487; break;
18600     case 448:
18601       var $11456=$2;
18602       var $11457=(($11456+64)|0);
18603       var $11458=HEAP32[(($11457)>>2)];
18604       var $11459=$st;
18605       var $11460=(($11459+2)|0);
18606       var $11461=$11460;
18607       var $11462=HEAP16[(($11461)>>1)];
18608       var $11463=(($11462)&65535);
18609       var $11464=(($11458+($11463<<2))|0);
18610       var $11465=$11464;
18611       var $11466=$11465;
18612       var $11467=HEAP32[(($11466)>>2)];
18613       var $11468=(($11467)|0)==0;
18614       var $11469=(($11468)&1);
18615       var $11470=(($11469)|0);
18616       var $11471=$2;
18617       var $11472=(($11471+64)|0);
18618       var $11473=HEAP32[(($11472)>>2)];
18619       var $11474=$st;
18620       var $11475=(($11474+6)|0);
18621       var $11476=$11475;
18622       var $11477=HEAP16[(($11476)>>1)];
18623       var $11478=(($11477)&65535);
18624       var $11479=(($11473+($11478<<2))|0);
18625       var $11480=$11479;
18626       var $11481=$11480;
18627       HEAPF32[(($11481)>>2)]=$11470;
18628       __label__ = 487; break;
18629     case 449:
18630       var $11483=$2;
18631       var $11484=(($11483+64)|0);
18632       var $11485=HEAP32[(($11484)>>2)];
18633       var $11486=$st;
18634       var $11487=(($11486+2)|0);
18635       var $11488=$11487;
18636       var $11489=HEAP16[(($11488)>>1)];
18637       var $11490=(($11489)&65535);
18638       var $11491=(($11485+($11490<<2))|0);
18639       var $11492=$11491;
18640       var $11493=$11492;
18641       var $11494=HEAP32[(($11493)>>2)];
18642       var $11495=(($11494)|0)!=0;
18643       var $11496=$11495 ^ 1;
18644       var $11497=(($11496)&1);
18645       var $11498=(($11497)|0);
18646       var $11499=$2;
18647       var $11500=(($11499+64)|0);
18648       var $11501=HEAP32[(($11500)>>2)];
18649       var $11502=$st;
18650       var $11503=(($11502+6)|0);
18651       var $11504=$11503;
18652       var $11505=HEAP16[(($11504)>>1)];
18653       var $11506=(($11505)&65535);
18654       var $11507=(($11501+($11506<<2))|0);
18655       var $11508=$11507;
18656       var $11509=$11508;
18657       HEAPF32[(($11509)>>2)]=$11498;
18658       __label__ = 487; break;
18659     case 450:
18660       var $11511=$2;
18661       var $11512=(($11511+64)|0);
18662       var $11513=HEAP32[(($11512)>>2)];
18663       var $11514=$st;
18664       var $11515=(($11514+2)|0);
18665       var $11516=$11515;
18666       var $11517=HEAP16[(($11516)>>1)];
18667       var $11518=(($11517)&65535);
18668       var $11519=(($11513+($11518<<2))|0);
18669       var $11520=$11519;
18670       var $11521=$11520;
18671       var $11522=HEAP32[(($11521)>>2)];
18672       var $11523=$11522 & 2147483647;
18673       var $11524=(($11523)|0)!=0;
18674       if ($11524) { __label__ = 451; break; } else { __label__ = 454; break; }
18675     case 451:
18676       var $11526=$st;
18677       var $11527=(($11526+4)|0);
18678       var $11528=$11527;
18679       var $11529=HEAP16[(($11528)>>1)];
18680       var $11530=(($11529 << 16) >> 16);
18681       var $11531=((($11530)-(1))|0);
18682       var $11532=$st;
18683       var $11533=(($11532+($11531<<3))|0);
18684       $st=$11533;
18685       var $11534=$jumpcount;
18686       var $11535=((($11534)+(1))|0);
18687       $jumpcount=$11535;
18688       var $11536=$5;
18689       var $11537=(($11535)|0) >= (($11536)|0);
18690       if ($11537) { __label__ = 452; break; } else { __label__ = 453; break; }
18691     case 452:
18692       var $11539=$2;
18693       var $11540=$2;
18694       var $11541=(($11540)|0);
18695       var $11542=HEAP32[(($11541)>>2)];
18696       var $11543=$jumpcount;
18697       _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));
18698       __label__ = 453; break;
18699     case 453:
18700       __label__ = 454; break;
18701     case 454:
18702       __label__ = 487; break;
18703     case 455:
18704       var $11547=$2;
18705       var $11548=(($11547+64)|0);
18706       var $11549=HEAP32[(($11548)>>2)];
18707       var $11550=$st;
18708       var $11551=(($11550+2)|0);
18709       var $11552=$11551;
18710       var $11553=HEAP16[(($11552)>>1)];
18711       var $11554=(($11553)&65535);
18712       var $11555=(($11549+($11554<<2))|0);
18713       var $11556=$11555;
18714       var $11557=$11556;
18715       var $11558=HEAP32[(($11557)>>2)];
18716       var $11559=$11558 & 2147483647;
18717       var $11560=(($11559)|0)!=0;
18718       if ($11560) { __label__ = 459; break; } else { __label__ = 456; break; }
18719     case 456:
18720       var $11562=$st;
18721       var $11563=(($11562+4)|0);
18722       var $11564=$11563;
18723       var $11565=HEAP16[(($11564)>>1)];
18724       var $11566=(($11565 << 16) >> 16);
18725       var $11567=((($11566)-(1))|0);
18726       var $11568=$st;
18727       var $11569=(($11568+($11567<<3))|0);
18728       $st=$11569;
18729       var $11570=$jumpcount;
18730       var $11571=((($11570)+(1))|0);
18731       $jumpcount=$11571;
18732       var $11572=$5;
18733       var $11573=(($11571)|0) >= (($11572)|0);
18734       if ($11573) { __label__ = 457; break; } else { __label__ = 458; break; }
18735     case 457:
18736       var $11575=$2;
18737       var $11576=$2;
18738       var $11577=(($11576)|0);
18739       var $11578=HEAP32[(($11577)>>2)];
18740       var $11579=$jumpcount;
18741       _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));
18742       __label__ = 458; break;
18743     case 458:
18744       __label__ = 459; break;
18745     case 459:
18746       __label__ = 487; break;
18747     case 460:
18748       var $11583=$st;
18749       var $11584=(($11583)|0);
18750       var $11585=HEAP16[(($11584)>>1)];
18751       var $11586=(($11585)&65535);
18752       var $11587=((($11586)-(51))|0);
18753       var $11588=$2;
18754       var $11589=(($11588+184)|0);
18755       HEAP32[(($11589)>>2)]=$11587;
18756       var $11590=$2;
18757       var $11591=(($11590+64)|0);
18758       var $11592=HEAP32[(($11591)>>2)];
18759       var $11593=$st;
18760       var $11594=(($11593+2)|0);
18761       var $11595=$11594;
18762       var $11596=HEAP16[(($11595)>>1)];
18763       var $11597=(($11596)&65535);
18764       var $11598=(($11592+($11597<<2))|0);
18765       var $11599=$11598;
18766       var $11600=$11599;
18767       var $11601=HEAP32[(($11600)>>2)];
18768       var $11602=(($11601)|0)!=0;
18769       if ($11602) { __label__ = 462; break; } else { __label__ = 461; break; }
18770     case 461:
18771       var $11604=$2;
18772       var $11605=$2;
18773       var $11606=(($11605)|0);
18774       var $11607=HEAP32[(($11606)>>2)];
18775       _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));
18776       __label__ = 462; break;
18777     case 462:
18778       var $11609=$2;
18779       var $11610=(($11609+64)|0);
18780       var $11611=HEAP32[(($11610)>>2)];
18781       var $11612=$st;
18782       var $11613=(($11612+2)|0);
18783       var $11614=$11613;
18784       var $11615=HEAP16[(($11614)>>1)];
18785       var $11616=(($11615)&65535);
18786       var $11617=(($11611+($11616<<2))|0);
18787       var $11618=$11617;
18788       var $11619=$11618;
18789       var $11620=HEAP32[(($11619)>>2)];
18790       var $11621=(($11620)|0)!=0;
18791       if ($11621) { __label__ = 463; break; } else { __label__ = 464; break; }
18792     case 463:
18793       var $11623=$2;
18794       var $11624=(($11623+64)|0);
18795       var $11625=HEAP32[(($11624)>>2)];
18796       var $11626=$st;
18797       var $11627=(($11626+2)|0);
18798       var $11628=$11627;
18799       var $11629=HEAP16[(($11628)>>1)];
18800       var $11630=(($11629)&65535);
18801       var $11631=(($11625+($11630<<2))|0);
18802       var $11632=$11631;
18803       var $11633=$11632;
18804       var $11634=HEAP32[(($11633)>>2)];
18805       var $11635=$2;
18806       var $11636=(($11635+44)|0);
18807       var $11637=HEAP32[(($11636)>>2)];
18808       var $11638=(($11634)>>>0) >= (($11637)>>>0);
18809       if ($11638) { __label__ = 464; break; } else { __label__ = 465; break; }
18810     case 464:
18811       var $11640=$2;
18812       var $11641=$2;
18813       var $11642=(($11641)|0);
18814       var $11643=HEAP32[(($11642)>>2)];
18815       _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));
18816       __label__ = 488; break;
18817     case 465:
18818       var $11645=$2;
18819       var $11646=(($11645+64)|0);
18820       var $11647=HEAP32[(($11646)>>2)];
18821       var $11648=$st;
18822       var $11649=(($11648+2)|0);
18823       var $11650=$11649;
18824       var $11651=HEAP16[(($11650)>>1)];
18825       var $11652=(($11651)&65535);
18826       var $11653=(($11647+($11652<<2))|0);
18827       var $11654=$11653;
18828       var $11655=$11654;
18829       var $11656=HEAP32[(($11655)>>2)];
18830       var $11657=$2;
18831       var $11658=(($11657+40)|0);
18832       var $11659=HEAP32[(($11658)>>2)];
18833       var $11660=(($11659+($11656)*(36))|0);
18834       $newf9=$11660;
18835       var $11661=$newf9;
18836       var $11662=(($11661+12)|0);
18837       var $11663=HEAP32[(($11662)>>2)];
18838       var $11664=((($11663)+(1))|0);
18839       HEAP32[(($11662)>>2)]=$11664;
18840       var $11665=$st;
18841       var $11666=$2;
18842       var $11667=(($11666+4)|0);
18843       var $11668=HEAP32[(($11667)>>2)];
18844       var $11669=$11665;
18845       var $11670=$11668;
18846       var $11671=((($11669)-($11670))|0);
18847       var $11672=((((($11671)|0))/(8))&-1);
18848       var $11673=((($11672)+(1))|0);
18849       var $11674=$2;
18850       var $11675=(($11674+176)|0);
18851       HEAP32[(($11675)>>2)]=$11673;
18852       var $11676=$newf9;
18853       var $11677=(($11676)|0);
18854       var $11678=HEAP32[(($11677)>>2)];
18855       var $11679=(($11678)|0) < 0;
18856       if ($11679) { __label__ = 466; break; } else { __label__ = 471; break; }
18857     case 466:
18858       var $11681=$newf9;
18859       var $11682=(($11681)|0);
18860       var $11683=HEAP32[(($11682)>>2)];
18861       var $11684=(((-$11683))|0);
18862       $builtinnumber12=$11684;
18863       var $11685=$builtinnumber12;
18864       var $11686=$2;
18865       var $11687=(($11686+132)|0);
18866       var $11688=HEAP32[(($11687)>>2)];
18867       var $11689=(($11685)>>>0) < (($11688)>>>0);
18868       if ($11689) { __label__ = 467; break; } else { __label__ = 469; break; }
18869     case 467:
18870       var $11691=$builtinnumber12;
18871       var $11692=$2;
18872       var $11693=(($11692+128)|0);
18873       var $11694=HEAP32[(($11693)>>2)];
18874       var $11695=(($11694+($11691<<2))|0);
18875       var $11696=HEAP32[(($11695)>>2)];
18876       var $11697=(($11696)|0)!=0;
18877       if ($11697) { __label__ = 468; break; } else { __label__ = 469; break; }
18878     case 468:
18879       var $11699=$builtinnumber12;
18880       var $11700=$2;
18881       var $11701=(($11700+128)|0);
18882       var $11702=HEAP32[(($11701)>>2)];
18883       var $11703=(($11702+($11699<<2))|0);
18884       var $11704=HEAP32[(($11703)>>2)];
18885       var $11705=$2;
18886       var $11706=FUNCTION_TABLE[$11704]($11705);
18887       __label__ = 470; break;
18888     case 469:
18889       var $11708=$2;
18890       var $11709=$builtinnumber12;
18891       var $11710=$2;
18892       var $11711=(($11710)|0);
18893       var $11712=HEAP32[(($11711)>>2)];
18894       _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));
18895       __label__ = 470; break;
18896     case 470:
18897       __label__ = 472; break;
18898     case 471:
18899       var $11715=$2;
18900       var $11716=(($11715+4)|0);
18901       var $11717=HEAP32[(($11716)>>2)];
18902       var $11718=$2;
18903       var $11719=$newf9;
18904       var $11720=_prog_enterfunction($11718, $11719);
18905       var $11721=(($11717+($11720<<3))|0);
18906       var $11722=((($11721)-(8))|0);
18907       $st=$11722;
18908       __label__ = 472; break;
18909     case 472:
18910       var $11724=$2;
18911       var $11725=(($11724+112)|0);
18912       var $11726=HEAP32[(($11725)>>2)];
18913       var $11727=(($11726)|0)!=0;
18914       if ($11727) { __label__ = 473; break; } else { __label__ = 474; break; }
18915     case 473:
18916       __label__ = 488; break;
18917     case 474:
18918       __label__ = 487; break;
18919     case 475:
18920       var $11731=$2;
18921       var $11732=$2;
18922       var $11733=(($11732)|0);
18923       var $11734=HEAP32[(($11733)>>2)];
18924       _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));
18925       __label__ = 487; break;
18926     case 476:
18927       var $11736=$st;
18928       var $11737=(($11736+2)|0);
18929       var $11738=$11737;
18930       var $11739=HEAP16[(($11738)>>1)];
18931       var $11740=(($11739 << 16) >> 16);
18932       var $11741=((($11740)-(1))|0);
18933       var $11742=$st;
18934       var $11743=(($11742+($11741<<3))|0);
18935       $st=$11743;
18936       var $11744=$jumpcount;
18937       var $11745=((($11744)+(1))|0);
18938       $jumpcount=$11745;
18939       var $11746=(($11745)|0)==10000000;
18940       if ($11746) { __label__ = 477; break; } else { __label__ = 478; break; }
18941     case 477:
18942       var $11748=$2;
18943       var $11749=$2;
18944       var $11750=(($11749)|0);
18945       var $11751=HEAP32[(($11750)>>2)];
18946       var $11752=$jumpcount;
18947       _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));
18948       __label__ = 478; break;
18949     case 478:
18950       __label__ = 487; break;
18951     case 479:
18952       var $11755=$2;
18953       var $11756=(($11755+64)|0);
18954       var $11757=HEAP32[(($11756)>>2)];
18955       var $11758=$st;
18956       var $11759=(($11758+2)|0);
18957       var $11760=$11759;
18958       var $11761=HEAP16[(($11760)>>1)];
18959       var $11762=(($11761)&65535);
18960       var $11763=(($11757+($11762<<2))|0);
18961       var $11764=$11763;
18962       var $11765=$11764;
18963       var $11766=HEAP32[(($11765)>>2)];
18964       var $11767=$11766 & 2147483647;
18965       var $11768=(($11767)|0)!=0;
18966       if ($11768) { __label__ = 480; break; } else { var $11785 = 0;__label__ = 481; break; }
18967     case 480:
18968       var $11770=$2;
18969       var $11771=(($11770+64)|0);
18970       var $11772=HEAP32[(($11771)>>2)];
18971       var $11773=$st;
18972       var $11774=(($11773+4)|0);
18973       var $11775=$11774;
18974       var $11776=HEAP16[(($11775)>>1)];
18975       var $11777=(($11776)&65535);
18976       var $11778=(($11772+($11777<<2))|0);
18977       var $11779=$11778;
18978       var $11780=$11779;
18979       var $11781=HEAP32[(($11780)>>2)];
18980       var $11782=$11781 & 2147483647;
18981       var $11783=(($11782)|0)!=0;
18982       var $11785 = $11783;__label__ = 481; break;
18983     case 481:
18984       var $11785;
18985       var $11786=(($11785)&1);
18986       var $11787=(($11786)|0);
18987       var $11788=$2;
18988       var $11789=(($11788+64)|0);
18989       var $11790=HEAP32[(($11789)>>2)];
18990       var $11791=$st;
18991       var $11792=(($11791+6)|0);
18992       var $11793=$11792;
18993       var $11794=HEAP16[(($11793)>>1)];
18994       var $11795=(($11794)&65535);
18995       var $11796=(($11790+($11795<<2))|0);
18996       var $11797=$11796;
18997       var $11798=$11797;
18998       HEAPF32[(($11798)>>2)]=$11787;
18999       __label__ = 487; break;
19000     case 482:
19001       var $11800=$2;
19002       var $11801=(($11800+64)|0);
19003       var $11802=HEAP32[(($11801)>>2)];
19004       var $11803=$st;
19005       var $11804=(($11803+2)|0);
19006       var $11805=$11804;
19007       var $11806=HEAP16[(($11805)>>1)];
19008       var $11807=(($11806)&65535);
19009       var $11808=(($11802+($11807<<2))|0);
19010       var $11809=$11808;
19011       var $11810=$11809;
19012       var $11811=HEAP32[(($11810)>>2)];
19013       var $11812=$11811 & 2147483647;
19014       var $11813=(($11812)|0)!=0;
19015       if ($11813) { var $11830 = 1;__label__ = 484; break; } else { __label__ = 483; break; }
19016     case 483:
19017       var $11815=$2;
19018       var $11816=(($11815+64)|0);
19019       var $11817=HEAP32[(($11816)>>2)];
19020       var $11818=$st;
19021       var $11819=(($11818+4)|0);
19022       var $11820=$11819;
19023       var $11821=HEAP16[(($11820)>>1)];
19024       var $11822=(($11821)&65535);
19025       var $11823=(($11817+($11822<<2))|0);
19026       var $11824=$11823;
19027       var $11825=$11824;
19028       var $11826=HEAP32[(($11825)>>2)];
19029       var $11827=$11826 & 2147483647;
19030       var $11828=(($11827)|0)!=0;
19031       var $11830 = $11828;__label__ = 484; break;
19032     case 484:
19033       var $11830;
19034       var $11831=(($11830)&1);
19035       var $11832=(($11831)|0);
19036       var $11833=$2;
19037       var $11834=(($11833+64)|0);
19038       var $11835=HEAP32[(($11834)>>2)];
19039       var $11836=$st;
19040       var $11837=(($11836+6)|0);
19041       var $11838=$11837;
19042       var $11839=HEAP16[(($11838)>>1)];
19043       var $11840=(($11839)&65535);
19044       var $11841=(($11835+($11840<<2))|0);
19045       var $11842=$11841;
19046       var $11843=$11842;
19047       HEAPF32[(($11843)>>2)]=$11832;
19048       __label__ = 487; break;
19049     case 485:
19050       var $11845=$2;
19051       var $11846=(($11845+64)|0);
19052       var $11847=HEAP32[(($11846)>>2)];
19053       var $11848=$st;
19054       var $11849=(($11848+2)|0);
19055       var $11850=$11849;
19056       var $11851=HEAP16[(($11850)>>1)];
19057       var $11852=(($11851)&65535);
19058       var $11853=(($11847+($11852<<2))|0);
19059       var $11854=$11853;
19060       var $11855=$11854;
19061       var $11856=HEAPF32[(($11855)>>2)];
19062       var $11857=(($11856)&-1);
19063       var $11858=$2;
19064       var $11859=(($11858+64)|0);
19065       var $11860=HEAP32[(($11859)>>2)];
19066       var $11861=$st;
19067       var $11862=(($11861+4)|0);
19068       var $11863=$11862;
19069       var $11864=HEAP16[(($11863)>>1)];
19070       var $11865=(($11864)&65535);
19071       var $11866=(($11860+($11865<<2))|0);
19072       var $11867=$11866;
19073       var $11868=$11867;
19074       var $11869=HEAPF32[(($11868)>>2)];
19075       var $11870=(($11869)&-1);
19076       var $11871=$11857 & $11870;
19077       var $11872=(($11871)|0);
19078       var $11873=$2;
19079       var $11874=(($11873+64)|0);
19080       var $11875=HEAP32[(($11874)>>2)];
19081       var $11876=$st;
19082       var $11877=(($11876+6)|0);
19083       var $11878=$11877;
19084       var $11879=HEAP16[(($11878)>>1)];
19085       var $11880=(($11879)&65535);
19086       var $11881=(($11875+($11880<<2))|0);
19087       var $11882=$11881;
19088       var $11883=$11882;
19089       HEAPF32[(($11883)>>2)]=$11872;
19090       __label__ = 487; break;
19091     case 486:
19092       var $11885=$2;
19093       var $11886=(($11885+64)|0);
19094       var $11887=HEAP32[(($11886)>>2)];
19095       var $11888=$st;
19096       var $11889=(($11888+2)|0);
19097       var $11890=$11889;
19098       var $11891=HEAP16[(($11890)>>1)];
19099       var $11892=(($11891)&65535);
19100       var $11893=(($11887+($11892<<2))|0);
19101       var $11894=$11893;
19102       var $11895=$11894;
19103       var $11896=HEAPF32[(($11895)>>2)];
19104       var $11897=(($11896)&-1);
19105       var $11898=$2;
19106       var $11899=(($11898+64)|0);
19107       var $11900=HEAP32[(($11899)>>2)];
19108       var $11901=$st;
19109       var $11902=(($11901+4)|0);
19110       var $11903=$11902;
19111       var $11904=HEAP16[(($11903)>>1)];
19112       var $11905=(($11904)&65535);
19113       var $11906=(($11900+($11905<<2))|0);
19114       var $11907=$11906;
19115       var $11908=$11907;
19116       var $11909=HEAPF32[(($11908)>>2)];
19117       var $11910=(($11909)&-1);
19118       var $11911=$11897 | $11910;
19119       var $11912=(($11911)|0);
19120       var $11913=$2;
19121       var $11914=(($11913+64)|0);
19122       var $11915=HEAP32[(($11914)>>2)];
19123       var $11916=$st;
19124       var $11917=(($11916+6)|0);
19125       var $11918=$11917;
19126       var $11919=HEAP16[(($11918)>>1)];
19127       var $11920=(($11919)&65535);
19128       var $11921=(($11915+($11920<<2))|0);
19129       var $11922=$11921;
19130       var $11923=$11922;
19131       HEAPF32[(($11923)>>2)]=$11912;
19132       __label__ = 487; break;
19133     case 487:
19134       __label__ = 368; break;
19135     case 488:
19136       var $11926=$oldxflags;
19137       var $11927=$2;
19138       var $11928=(($11927+180)|0);
19139       HEAP32[(($11928)>>2)]=$11926;
19140       var $11929=$2;
19141       var $11930=(($11929+156)|0);
19142       HEAP32[(($11930)>>2)]=0;
19143       var $11931=$2;
19144       var $11932=(($11931+168)|0);
19145       HEAP32[(($11932)>>2)]=0;
19146       var $11933=$2;
19147       var $11934=(($11933+112)|0);
19148       var $11935=HEAP32[(($11934)>>2)];
19149       var $11936=(($11935)|0)!=0;
19150       if ($11936) { __label__ = 489; break; } else { __label__ = 490; break; }
19151     case 489:
19152       $1=0;
19153       __label__ = 491; break;
19154     case 490:
19155       $1=1;
19156       __label__ = 491; break;
19157     case 491:
19158       var $11940=$1;
19159       STACKTOP = __stackBase__;
19160       return $11940;
19161     default: assert(0, "bad label: " + __label__);
19162   }
19163 }
19164 _prog_exec["X"]=1;
19165
19166 function _qcvmerror($prog, $fmt) {
19167   var __stackBase__  = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19168   var __label__;
19169
19170   var $1;
19171   var $2;
19172   var $ap=__stackBase__;
19173   $1=$prog;
19174   $2=$fmt;
19175   var $3=$1;
19176   var $4=(($3+112)|0);
19177   var $5=HEAP32[(($4)>>2)];
19178   var $6=((($5)+(1))|0);
19179   HEAP32[(($4)>>2)]=$6;
19180   var $7=$ap;
19181   HEAP32[(($7)>>2)]=arguments[_qcvmerror.length];
19182   var $8=$2;
19183   var $9=HEAP32[(($ap)>>2)];
19184   var $10=_vprintf($8, $9);
19185   var $11=$ap;
19186   ;
19187   var $12=HEAP32[((_stdout)>>2)];
19188   var $13=_putc(10, $12);
19189   STACKTOP = __stackBase__;
19190   return;
19191 }
19192
19193
19194 function _prog_print_statement($prog, $st) {
19195   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19196   var __label__;
19197   __label__ = 2;
19198   while(1) switch(__label__) {
19199     case 2:
19200       var $1;
19201       var $2;
19202       var $t=__stackBase__;
19203       $1=$prog;
19204       $2=$st;
19205       var $3=$2;
19206       var $4=(($3)|0);
19207       var $5=HEAP16[(($4)>>1)];
19208       var $6=(($5)&65535);
19209       var $7=(($6)>>>0) >= 67;
19210       if ($7) { __label__ = 3; break; } else { __label__ = 4; break; }
19211     case 3:
19212       var $9=$2;
19213       var $10=(($9)|0);
19214       var $11=HEAP16[(($10)>>1)];
19215       var $12=(($11)&65535);
19216       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));
19217       __label__ = 42; break;
19218     case 4:
19219       var $15=$2;
19220       var $16=(($15)|0);
19221       var $17=HEAP16[(($16)>>1)];
19222       var $18=(($17)&65535);
19223       var $19=((_asm_instr+($18)*(12))|0);
19224       var $20=(($19)|0);
19225       var $21=HEAP32[(($20)>>2)];
19226       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));
19227       var $23=$2;
19228       var $24=(($23)|0);
19229       var $25=HEAP16[(($24)>>1)];
19230       var $26=(($25)&65535);
19231       var $27=(($26)|0) >= 49;
19232       if ($27) { __label__ = 5; break; } else { __label__ = 7; break; }
19233     case 5:
19234       var $29=$2;
19235       var $30=(($29)|0);
19236       var $31=HEAP16[(($30)>>1)];
19237       var $32=(($31)&65535);
19238       var $33=(($32)|0) <= 50;
19239       if ($33) { __label__ = 6; break; } else { __label__ = 7; break; }
19240     case 6:
19241       var $35=$1;
19242       var $36=$2;
19243       var $37=(($36+2)|0);
19244       var $38=$37;
19245       var $39=HEAP16[(($38)>>1)];
19246       var $40=(($39)&65535);
19247       _trace_print_global($35, $40, 2);
19248       var $41=$2;
19249       var $42=(($41+4)|0);
19250       var $43=$42;
19251       var $44=HEAP16[(($43)>>1)];
19252       var $45=(($44 << 16) >> 16);
19253       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));
19254       __label__ = 41; break;
19255     case 7:
19256       var $48=$2;
19257       var $49=(($48)|0);
19258       var $50=HEAP16[(($49)>>1)];
19259       var $51=(($50)&65535);
19260       var $52=(($51)|0) >= 51;
19261       if ($52) { __label__ = 8; break; } else { __label__ = 10; break; }
19262     case 8:
19263       var $54=$2;
19264       var $55=(($54)|0);
19265       var $56=HEAP16[(($55)>>1)];
19266       var $57=(($56)&65535);
19267       var $58=(($57)|0) <= 59;
19268       if ($58) { __label__ = 9; break; } else { __label__ = 10; break; }
19269     case 9:
19270       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));
19271       __label__ = 40; break;
19272     case 10:
19273       var $62=$2;
19274       var $63=(($62)|0);
19275       var $64=HEAP16[(($63)>>1)];
19276       var $65=(($64)&65535);
19277       var $66=(($65)|0)==61;
19278       if ($66) { __label__ = 11; break; } else { __label__ = 12; break; }
19279     case 11:
19280       var $68=$2;
19281       var $69=(($68+2)|0);
19282       var $70=$69;
19283       var $71=HEAP16[(($70)>>1)];
19284       var $72=(($71 << 16) >> 16);
19285       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));
19286       __label__ = 39; break;
19287     case 12:
19288       var $75=$t;
19289       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)];
19290       var $76=$2;
19291       var $77=(($76)|0);
19292       var $78=HEAP16[(($77)>>1)];
19293       var $79=(($78)&65535);
19294       if ((($79)|0) == 3) {
19295         __label__ = 13; break;
19296       }
19297       else if ((($79)|0) == 4) {
19298         __label__ = 14; break;
19299       }
19300       else if ((($79)|0) == 2) {
19301         __label__ = 15; break;
19302       }
19303       else if ((($79)|0) == 7 || (($79)|0) == 9 || (($79)|0) == 11 || (($79)|0) == 16) {
19304         __label__ = 16; break;
19305       }
19306       else if ((($79)|0) == 12 || (($79)|0) == 17) {
19307         __label__ = 17; break;
19308       }
19309       else if ((($79)|0) == 31 || (($79)|0) == 37) {
19310         __label__ = 18; break;
19311       }
19312       else if ((($79)|0) == 32) {
19313         __label__ = 19; break;
19314       }
19315       else if ((($79)|0) == 33) {
19316         __label__ = 20; break;
19317       }
19318       else if ((($79)|0) == 34) {
19319         __label__ = 21; break;
19320       }
19321       else if ((($79)|0) == 35) {
19322         __label__ = 22; break;
19323       }
19324       else if ((($79)|0) == 36) {
19325         __label__ = 23; break;
19326       }
19327       else if ((($79)|0) == 38) {
19328         __label__ = 24; break;
19329       }
19330       else if ((($79)|0) == 39) {
19331         __label__ = 25; break;
19332       }
19333       else if ((($79)|0) == 40) {
19334         __label__ = 26; break;
19335       }
19336       else if ((($79)|0) == 41) {
19337         __label__ = 27; break;
19338       }
19339       else if ((($79)|0) == 42) {
19340         __label__ = 28; break;
19341       }
19342       else {
19343       __label__ = 29; break;
19344       }
19345
19346     case 13:
19347       var $81=(($t+8)|0);
19348       HEAP32[(($81)>>2)]=3;
19349       var $82=(($t+4)|0);
19350       HEAP32[(($82)>>2)]=3;
19351       __label__ = 29; break;
19352     case 14:
19353       var $84=(($t+8)|0);
19354       HEAP32[(($84)>>2)]=3;
19355       var $85=(($t)|0);
19356       HEAP32[(($85)>>2)]=3;
19357       __label__ = 29; break;
19358     case 15:
19359       var $87=(($t+4)|0);
19360       HEAP32[(($87)>>2)]=3;
19361       var $88=(($t)|0);
19362       HEAP32[(($88)>>2)]=3;
19363       __label__ = 29; break;
19364     case 16:
19365       var $90=(($t+8)|0);
19366       HEAP32[(($90)>>2)]=3;
19367       var $91=(($t+4)|0);
19368       HEAP32[(($91)>>2)]=3;
19369       var $92=(($t)|0);
19370       HEAP32[(($92)>>2)]=3;
19371       __label__ = 29; break;
19372     case 17:
19373       var $94=(($t+4)|0);
19374       HEAP32[(($94)>>2)]=1;
19375       var $95=(($t)|0);
19376       HEAP32[(($95)>>2)]=1;
19377       __label__ = 29; break;
19378     case 18:
19379       var $97=(($t+8)|0);
19380       HEAP32[(($97)>>2)]=-1;
19381       __label__ = 29; break;
19382     case 19:
19383       var $99=(($t+4)|0);
19384       HEAP32[(($99)>>2)]=3;
19385       var $100=(($t)|0);
19386       HEAP32[(($100)>>2)]=3;
19387       var $101=(($t+8)|0);
19388       HEAP32[(($101)>>2)]=-1;
19389       __label__ = 29; break;
19390     case 20:
19391       var $103=(($t+4)|0);
19392       HEAP32[(($103)>>2)]=1;
19393       var $104=(($t)|0);
19394       HEAP32[(($104)>>2)]=1;
19395       var $105=(($t+8)|0);
19396       HEAP32[(($105)>>2)]=-1;
19397       __label__ = 29; break;
19398     case 21:
19399       var $107=(($t+4)|0);
19400       HEAP32[(($107)>>2)]=4;
19401       var $108=(($t)|0);
19402       HEAP32[(($108)>>2)]=4;
19403       var $109=(($t+8)|0);
19404       HEAP32[(($109)>>2)]=-1;
19405       __label__ = 29; break;
19406     case 22:
19407       var $111=(($t+4)|0);
19408       HEAP32[(($111)>>2)]=5;
19409       var $112=(($t)|0);
19410       HEAP32[(($112)>>2)]=5;
19411       var $113=(($t+8)|0);
19412       HEAP32[(($113)>>2)]=-1;
19413       __label__ = 29; break;
19414     case 23:
19415       var $115=(($t+4)|0);
19416       HEAP32[(($115)>>2)]=6;
19417       var $116=(($t)|0);
19418       HEAP32[(($116)>>2)]=6;
19419       var $117=(($t+8)|0);
19420       HEAP32[(($117)>>2)]=-1;
19421       __label__ = 29; break;
19422     case 24:
19423       var $119=(($t)|0);
19424       HEAP32[(($119)>>2)]=3;
19425       var $120=(($t+4)|0);
19426       HEAP32[(($120)>>2)]=4;
19427       var $121=(($t+8)|0);
19428       HEAP32[(($121)>>2)]=-1;
19429       __label__ = 29; break;
19430     case 25:
19431       var $123=(($t)|0);
19432       HEAP32[(($123)>>2)]=1;
19433       var $124=(($t+4)|0);
19434       HEAP32[(($124)>>2)]=4;
19435       var $125=(($t+8)|0);
19436       HEAP32[(($125)>>2)]=-1;
19437       __label__ = 29; break;
19438     case 26:
19439       var $127=(($t)|0);
19440       HEAP32[(($127)>>2)]=4;
19441       var $128=(($t+4)|0);
19442       HEAP32[(($128)>>2)]=4;
19443       var $129=(($t+8)|0);
19444       HEAP32[(($129)>>2)]=-1;
19445       __label__ = 29; break;
19446     case 27:
19447       var $131=(($t)|0);
19448       HEAP32[(($131)>>2)]=5;
19449       var $132=(($t+4)|0);
19450       HEAP32[(($132)>>2)]=4;
19451       var $133=(($t+8)|0);
19452       HEAP32[(($133)>>2)]=-1;
19453       __label__ = 29; break;
19454     case 28:
19455       var $135=(($t)|0);
19456       HEAP32[(($135)>>2)]=6;
19457       var $136=(($t+4)|0);
19458       HEAP32[(($136)>>2)]=4;
19459       var $137=(($t+8)|0);
19460       HEAP32[(($137)>>2)]=-1;
19461       __label__ = 29; break;
19462     case 29:
19463       var $139=(($t)|0);
19464       var $140=HEAP32[(($139)>>2)];
19465       var $141=(($140)|0) >= 0;
19466       if ($141) { __label__ = 30; break; } else { __label__ = 31; break; }
19467     case 30:
19468       var $143=$1;
19469       var $144=$2;
19470       var $145=(($144+2)|0);
19471       var $146=$145;
19472       var $147=HEAP16[(($146)>>1)];
19473       var $148=(($147)&65535);
19474       var $149=(($t)|0);
19475       var $150=HEAP32[(($149)>>2)];
19476       _trace_print_global($143, $148, $150);
19477       __label__ = 32; break;
19478     case 31:
19479       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));
19480       __label__ = 32; break;
19481     case 32:
19482       var $154=(($t+4)|0);
19483       var $155=HEAP32[(($154)>>2)];
19484       var $156=(($155)|0) >= 0;
19485       if ($156) { __label__ = 33; break; } else { __label__ = 34; break; }
19486     case 33:
19487       var $158=$1;
19488       var $159=$2;
19489       var $160=(($159+4)|0);
19490       var $161=$160;
19491       var $162=HEAP16[(($161)>>1)];
19492       var $163=(($162)&65535);
19493       var $164=(($t+4)|0);
19494       var $165=HEAP32[(($164)>>2)];
19495       _trace_print_global($158, $163, $165);
19496       __label__ = 35; break;
19497     case 34:
19498       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));
19499       __label__ = 35; break;
19500     case 35:
19501       var $169=(($t+8)|0);
19502       var $170=HEAP32[(($169)>>2)];
19503       var $171=(($170)|0) >= 0;
19504       if ($171) { __label__ = 36; break; } else { __label__ = 37; break; }
19505     case 36:
19506       var $173=$1;
19507       var $174=$2;
19508       var $175=(($174+6)|0);
19509       var $176=$175;
19510       var $177=HEAP16[(($176)>>1)];
19511       var $178=(($177)&65535);
19512       var $179=(($t+8)|0);
19513       var $180=HEAP32[(($179)>>2)];
19514       _trace_print_global($173, $178, $180);
19515       __label__ = 38; break;
19516     case 37:
19517       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));
19518       __label__ = 38; break;
19519     case 38:
19520       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));
19521       __label__ = 39; break;
19522     case 39:
19523       __label__ = 40; break;
19524     case 40:
19525       __label__ = 41; break;
19526     case 41:
19527       var $188=HEAP32[((_stdout)>>2)];
19528       var $189=_fflush($188);
19529       __label__ = 42; break;
19530     case 42:
19531       STACKTOP = __stackBase__;
19532       return;
19533     default: assert(0, "bad label: " + __label__);
19534   }
19535 }
19536 _prog_print_statement["X"]=1;
19537
19538 function _trace_print_global($prog, $glob, $vtype) {
19539   var __stackBase__  = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19540   var __label__;
19541   __label__ = 2;
19542   while(1) switch(__label__) {
19543     case 2:
19544       var $1;
19545       var $2;
19546       var $3;
19547       var $def;
19548       var $value;
19549       var $len;
19550       var $name;
19551       $1=$prog;
19552       $2=$glob;
19553       $3=$vtype;
19554       var $4=$2;
19555       var $5=(($4)|0)!=0;
19556       if ($5) { __label__ = 4; break; } else { __label__ = 3; break; }
19557     case 3:
19558       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));
19559       $len=$7;
19560       __label__ = 17; break;
19561     case 4:
19562       var $9=$1;
19563       var $10=$2;
19564       var $11=_prog_getdef($9, $10);
19565       $def=$11;
19566       var $12=$2;
19567       var $13=$1;
19568       var $14=(($13+64)|0);
19569       var $15=HEAP32[(($14)>>2)];
19570       var $16=(($15+($12<<2))|0);
19571       var $17=$16;
19572       $value=$17;
19573       var $18=$def;
19574       var $19=(($18)|0)!=0;
19575       if ($19) { __label__ = 5; break; } else { __label__ = 9; break; }
19576     case 5:
19577       var $21=$1;
19578       var $22=$def;
19579       var $23=(($22+4)|0);
19580       var $24=HEAP32[(($23)>>2)];
19581       var $25=_prog_getstring($21, $24);
19582       $name=$25;
19583       var $26=$name;
19584       var $27=(($26)|0);
19585       var $28=HEAP8[($27)];
19586       var $29=(($28 << 24) >> 24);
19587       var $30=(($29)|0)==35;
19588       if ($30) { __label__ = 6; break; } else { __label__ = 7; break; }
19589     case 6:
19590       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));
19591       $len=$32;
19592       __label__ = 8; break;
19593     case 7:
19594       var $34=$name;
19595       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));
19596       $len=$35;
19597       __label__ = 8; break;
19598     case 8:
19599       var $37=$def;
19600       var $38=(($37)|0);
19601       var $39=HEAP16[(($38)>>1)];
19602       var $40=(($39)&65535);
19603       $3=$40;
19604       __label__ = 10; break;
19605     case 9:
19606       var $42=$2;
19607       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));
19608       $len=$43;
19609       __label__ = 10; break;
19610     case 10:
19611       var $45=$3;
19612       if ((($45)|0) == 0 || (($45)|0) == 4 || (($45)|0) == 5 || (($45)|0) == 6 || (($45)|0) == 7) {
19613         __label__ = 11; break;
19614       }
19615       else if ((($45)|0) == 3) {
19616         __label__ = 12; break;
19617       }
19618       else if ((($45)|0) == 1) {
19619         __label__ = 13; break;
19620       }
19621       else if ((($45)|0) == 2) {
19622         __label__ = 14; break;
19623       }
19624       else {
19625       __label__ = 15; break;
19626       }
19627
19628     case 11:
19629       var $47=$value;
19630       var $48=$47;
19631       var $49=HEAP32[(($48)>>2)];
19632       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));
19633       var $51=$len;
19634       var $52=((($51)+($50))|0);
19635       $len=$52;
19636       __label__ = 16; break;
19637     case 12:
19638       var $54=$value;
19639       var $55=$54;
19640       var $56=(($55)|0);
19641       var $57=HEAPF32[(($56)>>2)];
19642       var $58=$57;
19643       var $59=$value;
19644       var $60=$59;
19645       var $61=(($60+4)|0);
19646       var $62=HEAPF32[(($61)>>2)];
19647       var $63=$62;
19648       var $64=$value;
19649       var $65=$64;
19650       var $66=(($65+8)|0);
19651       var $67=HEAPF32[(($66)>>2)];
19652       var $68=$67;
19653       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));
19654       var $70=$len;
19655       var $71=((($70)+($69))|0);
19656       $len=$71;
19657       __label__ = 16; break;
19658     case 13:
19659       var $73=$1;
19660       var $74=$value;
19661       var $75=$74;
19662       var $76=HEAP32[(($75)>>2)];
19663       var $77=_prog_getstring($73, $76);
19664       var $78=$len;
19665       var $79=(((29)-($78))|0);
19666       var $80=((($79)-(5))|0);
19667       var $81=_print_escaped_string($77, $80);
19668       var $82=$len;
19669       var $83=((($82)+($81))|0);
19670       $len=$83;
19671       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));
19672       var $85=$len;
19673       var $86=((($85)+($84))|0);
19674       $len=$86;
19675       __label__ = 16; break;
19676     case 14:
19677       __label__ = 15; break;
19678     case 15:
19679       var $89=$value;
19680       var $90=$89;
19681       var $91=HEAPF32[(($90)>>2)];
19682       var $92=$91;
19683       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));
19684       var $94=$len;
19685       var $95=((($94)+($93))|0);
19686       $len=$95;
19687       __label__ = 16; break;
19688     case 16:
19689       __label__ = 17; break;
19690     case 17:
19691       var $98=$len;
19692       var $99=(($98)>>>0) < 28;
19693       if ($99) { __label__ = 18; break; } else { __label__ = 19; break; }
19694     case 18:
19695       var $101=$len;
19696       var $102=(((28)-($101))|0);
19697       var $103=((STRING_TABLE._trace_print_global_spaces+$102)|0);
19698       HEAP8[($103)]=0;
19699       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));
19700       var $105=$len;
19701       var $106=(((28)-($105))|0);
19702       var $107=((STRING_TABLE._trace_print_global_spaces+$106)|0);
19703       HEAP8[($107)]=32;
19704       __label__ = 19; break;
19705     case 19:
19706       STACKTOP = __stackBase__;
19707       return;
19708     default: assert(0, "bad label: " + __label__);
19709   }
19710 }
19711 _trace_print_global["X"]=1;
19712
19713 function _print_escaped_string($str, $maxlen) {
19714   ;
19715   var __label__;
19716   __label__ = 2;
19717   while(1) switch(__label__) {
19718     case 2:
19719       var $1;
19720       var $2;
19721       var $len;
19722       $1=$str;
19723       $2=$maxlen;
19724       $len=2;
19725       var $3=HEAP32[((_stdout)>>2)];
19726       var $4=_putc(34, $3);
19727       var $5=$2;
19728       var $6=((($5)-(1))|0);
19729       $2=$6;
19730       __label__ = 3; break;
19731     case 3:
19732       var $8=$1;
19733       var $9=HEAP8[($8)];
19734       var $10=(($9 << 24) >> 24)!=0;
19735       if ($10) { __label__ = 4; break; } else { __label__ = 18; break; }
19736     case 4:
19737       var $12=$len;
19738       var $13=$2;
19739       var $14=(($12)>>>0) >= (($13)>>>0);
19740       if ($14) { __label__ = 5; break; } else { __label__ = 6; break; }
19741     case 5:
19742       var $16=HEAP32[((_stdout)>>2)];
19743       var $17=_putc(46, $16);
19744       var $18=HEAP32[((_stdout)>>2)];
19745       var $19=_putc(46, $18);
19746       var $20=HEAP32[((_stdout)>>2)];
19747       var $21=_putc(46, $20);
19748       var $22=$len;
19749       var $23=((($22)+(3))|0);
19750       $len=$23;
19751       __label__ = 18; break;
19752     case 6:
19753       var $25=$1;
19754       var $26=HEAP8[($25)];
19755       var $27=(($26 << 24) >> 24);
19756       if ((($27)|0) == 7) {
19757         __label__ = 7; break;
19758       }
19759       else if ((($27)|0) == 8) {
19760         __label__ = 8; break;
19761       }
19762       else if ((($27)|0) == 13) {
19763         __label__ = 9; break;
19764       }
19765       else if ((($27)|0) == 10) {
19766         __label__ = 10; break;
19767       }
19768       else if ((($27)|0) == 9) {
19769         __label__ = 11; break;
19770       }
19771       else if ((($27)|0) == 12) {
19772         __label__ = 12; break;
19773       }
19774       else if ((($27)|0) == 11) {
19775         __label__ = 13; break;
19776       }
19777       else if ((($27)|0) == 92) {
19778         __label__ = 14; break;
19779       }
19780       else if ((($27)|0) == 34) {
19781         __label__ = 15; break;
19782       }
19783       else {
19784       __label__ = 16; break;
19785       }
19786
19787     case 7:
19788       var $29=$len;
19789       var $30=((($29)+(2))|0);
19790       $len=$30;
19791       var $31=HEAP32[((_stdout)>>2)];
19792       var $32=_putc(92, $31);
19793       var $33=HEAP32[((_stdout)>>2)];
19794       var $34=_putc(97, $33);
19795       __label__ = 17; break;
19796     case 8:
19797       var $36=$len;
19798       var $37=((($36)+(2))|0);
19799       $len=$37;
19800       var $38=HEAP32[((_stdout)>>2)];
19801       var $39=_putc(92, $38);
19802       var $40=HEAP32[((_stdout)>>2)];
19803       var $41=_putc(98, $40);
19804       __label__ = 17; break;
19805     case 9:
19806       var $43=$len;
19807       var $44=((($43)+(2))|0);
19808       $len=$44;
19809       var $45=HEAP32[((_stdout)>>2)];
19810       var $46=_putc(92, $45);
19811       var $47=HEAP32[((_stdout)>>2)];
19812       var $48=_putc(114, $47);
19813       __label__ = 17; break;
19814     case 10:
19815       var $50=$len;
19816       var $51=((($50)+(2))|0);
19817       $len=$51;
19818       var $52=HEAP32[((_stdout)>>2)];
19819       var $53=_putc(92, $52);
19820       var $54=HEAP32[((_stdout)>>2)];
19821       var $55=_putc(110, $54);
19822       __label__ = 17; break;
19823     case 11:
19824       var $57=$len;
19825       var $58=((($57)+(2))|0);
19826       $len=$58;
19827       var $59=HEAP32[((_stdout)>>2)];
19828       var $60=_putc(92, $59);
19829       var $61=HEAP32[((_stdout)>>2)];
19830       var $62=_putc(116, $61);
19831       __label__ = 17; break;
19832     case 12:
19833       var $64=$len;
19834       var $65=((($64)+(2))|0);
19835       $len=$65;
19836       var $66=HEAP32[((_stdout)>>2)];
19837       var $67=_putc(92, $66);
19838       var $68=HEAP32[((_stdout)>>2)];
19839       var $69=_putc(102, $68);
19840       __label__ = 17; break;
19841     case 13:
19842       var $71=$len;
19843       var $72=((($71)+(2))|0);
19844       $len=$72;
19845       var $73=HEAP32[((_stdout)>>2)];
19846       var $74=_putc(92, $73);
19847       var $75=HEAP32[((_stdout)>>2)];
19848       var $76=_putc(118, $75);
19849       __label__ = 17; break;
19850     case 14:
19851       var $78=$len;
19852       var $79=((($78)+(2))|0);
19853       $len=$79;
19854       var $80=HEAP32[((_stdout)>>2)];
19855       var $81=_putc(92, $80);
19856       var $82=HEAP32[((_stdout)>>2)];
19857       var $83=_putc(92, $82);
19858       __label__ = 17; break;
19859     case 15:
19860       var $85=$len;
19861       var $86=((($85)+(2))|0);
19862       $len=$86;
19863       var $87=HEAP32[((_stdout)>>2)];
19864       var $88=_putc(92, $87);
19865       var $89=HEAP32[((_stdout)>>2)];
19866       var $90=_putc(34, $89);
19867       __label__ = 17; break;
19868     case 16:
19869       var $92=$len;
19870       var $93=((($92)+(1))|0);
19871       $len=$93;
19872       var $94=$1;
19873       var $95=HEAP8[($94)];
19874       var $96=(($95 << 24) >> 24);
19875       var $97=HEAP32[((_stdout)>>2)];
19876       var $98=_putc($96, $97);
19877       __label__ = 17; break;
19878     case 17:
19879       var $100=$1;
19880       var $101=(($100+1)|0);
19881       $1=$101;
19882       __label__ = 3; break;
19883     case 18:
19884       var $103=HEAP32[((_stdout)>>2)];
19885       var $104=_putc(34, $103);
19886       var $105=$len;
19887       ;
19888       return $105;
19889     default: assert(0, "bad label: " + __label__);
19890   }
19891 }
19892 _print_escaped_string["X"]=1;
19893
19894 function _prog_enterfunction($prog, $func) {
19895   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
19896   var __label__;
19897   __label__ = 2;
19898   while(1) switch(__label__) {
19899     case 2:
19900       var $1;
19901       var $2;
19902       var $st=__stackBase__;
19903       var $p;
19904       var $parampos;
19905       var $globals;
19906       var $s;
19907       $1=$prog;
19908       $2=$func;
19909       var $3=$1;
19910       var $4=(($3+156)|0);
19911       var $5=HEAP32[(($4)>>2)];
19912       var $6=(($st+4)|0);
19913       HEAP32[(($6)>>2)]=$5;
19914       var $7=$1;
19915       var $8=(($7+176)|0);
19916       var $9=HEAP32[(($8)>>2)];
19917       var $10=(($st)|0);
19918       HEAP32[(($10)>>2)]=$9;
19919       var $11=$2;
19920       var $12=(($st+8)|0);
19921       HEAP32[(($12)>>2)]=$11;
19922       var $13=$1;
19923       var $14=(($13+64)|0);
19924       var $15=HEAP32[(($14)>>2)];
19925       var $16=$2;
19926       var $17=(($16+4)|0);
19927       var $18=HEAP32[(($17)>>2)];
19928       var $19=(($15+($18<<2))|0);
19929       $globals=$19;
19930       var $20=$1;
19931       var $21=$globals;
19932       var $22=$2;
19933       var $23=(($22+8)|0);
19934       var $24=HEAP32[(($23)>>2)];
19935       var $25=_qc_program_localstack_append($20, $21, $24);
19936       if ($25) { __label__ = 4; break; } else { __label__ = 3; break; }
19937     case 3:
19938       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));
19939       _exit(1);
19940       throw "Reached an unreachable!"
19941     case 4:
19942       var $29=$2;
19943       var $30=(($29+4)|0);
19944       var $31=HEAP32[(($30)>>2)];
19945       $parampos=$31;
19946       $p=0;
19947       __label__ = 5; break;
19948     case 5:
19949       var $33=$p;
19950       var $34=$2;
19951       var $35=(($34+24)|0);
19952       var $36=HEAP32[(($35)>>2)];
19953       var $37=(($33)>>>0) < (($36)>>>0);
19954       if ($37) { __label__ = 6; break; } else { __label__ = 12; break; }
19955     case 6:
19956       $s=0;
19957       __label__ = 7; break;
19958     case 7:
19959       var $40=$s;
19960       var $41=$p;
19961       var $42=$2;
19962       var $43=(($42+28)|0);
19963       var $44=(($43+$41)|0);
19964       var $45=HEAP8[($44)];
19965       var $46=(($45)&255);
19966       var $47=(($40)>>>0) < (($46)>>>0);
19967       if ($47) { __label__ = 8; break; } else { __label__ = 10; break; }
19968     case 8:
19969       var $49=$p;
19970       var $50=((($49)*(3))|0);
19971       var $51=((($50)+(4))|0);
19972       var $52=$s;
19973       var $53=((($51)+($52))|0);
19974       var $54=$1;
19975       var $55=(($54+64)|0);
19976       var $56=HEAP32[(($55)>>2)];
19977       var $57=(($56+($53<<2))|0);
19978       var $58=HEAP32[(($57)>>2)];
19979       var $59=$parampos;
19980       var $60=$1;
19981       var $61=(($60+64)|0);
19982       var $62=HEAP32[(($61)>>2)];
19983       var $63=(($62+($59<<2))|0);
19984       HEAP32[(($63)>>2)]=$58;
19985       var $64=$parampos;
19986       var $65=((($64)+(1))|0);
19987       $parampos=$65;
19988       __label__ = 9; break;
19989     case 9:
19990       var $67=$s;
19991       var $68=((($67)+(1))|0);
19992       $s=$68;
19993       __label__ = 7; break;
19994     case 10:
19995       __label__ = 11; break;
19996     case 11:
19997       var $71=$p;
19998       var $72=((($71)+(1))|0);
19999       $p=$72;
20000       __label__ = 5; break;
20001     case 12:
20002       var $74=$1;
20003       var $75=(($st)|0);
20004       var $76=HEAP32[(($75)>>2)];
20005       var $77=(($st+4)|0);
20006       var $78=HEAP32[(($77)>>2)];
20007       var $79=(($st+8)|0);
20008       var $80=HEAP32[(($79)>>2)];
20009       var $81=_qc_program_stack_add($74, $76, $78, $80);
20010       if ($81) { __label__ = 14; break; } else { __label__ = 13; break; }
20011     case 13:
20012       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));
20013       _exit(1);
20014       throw "Reached an unreachable!"
20015     case 14:
20016       var $85=$2;
20017       var $86=(($85)|0);
20018       var $87=HEAP32[(($86)>>2)];
20019       STACKTOP = __stackBase__;
20020       return $87;
20021     default: assert(0, "bad label: " + __label__);
20022   }
20023 }
20024 _prog_enterfunction["X"]=1;
20025
20026 function _prog_leavefunction($prog) {
20027   var __stackBase__  = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack");
20028   var __label__;
20029   __label__ = 2;
20030   while(1) switch(__label__) {
20031     case 2:
20032       var $1;
20033       var $prev;
20034       var $oldsp;
20035       var $st=__stackBase__;
20036       var $globals;
20037       $1=$prog;
20038       $prev=0;
20039       var $2=$1;
20040       var $3=(($2+168)|0);
20041       var $4=HEAP32[(($3)>>2)];
20042       var $5=((($4)-(1))|0);
20043       var $6=$1;
20044       var $7=(($6+164)|0);
20045       var $8=HEAP32[(($7)>>2)];
20046       var $9=(($8+($5)*(12))|0);
20047       var $10=$st;
20048       var $11=$9;
20049       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)];
20050       var $12=$1;
20051       var $13=(($12+168)|0);
20052       var $14=HEAP32[(($13)>>2)];
20053       var $15=((($14)-(1))|0);
20054       var $16=$1;
20055       var $17=(($16+164)|0);
20056       var $18=HEAP32[(($17)>>2)];
20057       var $19=(($18+($15)*(12))|0);
20058       var $20=(($19+8)|0);
20059       var $21=HEAP32[(($20)>>2)];
20060       $prev=$21;
20061       var $22=$1;
20062       var $23=(($22+168)|0);
20063       var $24=HEAP32[(($23)>>2)];
20064       var $25=((($24)-(1))|0);
20065       var $26=$1;
20066       var $27=(($26+164)|0);
20067       var $28=HEAP32[(($27)>>2)];
20068       var $29=(($28+($25)*(12))|0);
20069       var $30=(($29+4)|0);
20070       var $31=HEAP32[(($30)>>2)];
20071       $oldsp=$31;
20072       var $32=$prev;
20073       var $33=(($32)|0)!=0;
20074       if ($33) { __label__ = 3; break; } else { __label__ = 6; break; }
20075     case 3:
20076       var $35=$1;
20077       var $36=(($35+64)|0);
20078       var $37=HEAP32[(($36)>>2)];
20079       var $38=$prev;
20080       var $39=(($38+4)|0);
20081       var $40=HEAP32[(($39)>>2)];
20082       var $41=(($37+($40<<2))|0);
20083       $globals=$41;
20084       var $42=$globals;
20085       var $43=$42;
20086       var $44=$1;
20087       var $45=(($44+152)|0);
20088       var $46=HEAP32[(($45)>>2)];
20089       var $47=$oldsp;
20090       var $48=(($46+($47<<2))|0);
20091       var $49=$48;
20092       var $50=$prev;
20093       var $51=(($50+8)|0);
20094       var $52=HEAP32[(($51)>>2)];
20095       assert($52 % 1 === 0, 'memcpy given ' + $52 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($43, $49, $52, 4);
20096       var $53=$1;
20097       var $54=$oldsp;
20098       var $55=_qc_program_localstack_resize($53, $54);
20099       if ($55) { __label__ = 5; break; } else { __label__ = 4; break; }
20100     case 4:
20101       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));
20102       _exit(1);
20103       throw "Reached an unreachable!"
20104     case 5:
20105       __label__ = 6; break;
20106     case 6:
20107       var $60=$1;
20108       var $61=$1;
20109       var $62=(($61+168)|0);
20110       var $63=HEAP32[(($62)>>2)];
20111       var $64=((($63)-(1))|0);
20112       var $65=_qc_program_stack_remove($60, $64);
20113       if ($65) { __label__ = 8; break; } else { __label__ = 7; break; }
20114     case 7:
20115       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));
20116       _exit(1);
20117       throw "Reached an unreachable!"
20118     case 8:
20119       var $69=(($st)|0);
20120       var $70=HEAP32[(($69)>>2)];
20121       var $71=((($70)-(1))|0);
20122       STACKTOP = __stackBase__;
20123       return $71;
20124     default: assert(0, "bad label: " + __label__);
20125   }
20126 }
20127 _prog_leavefunction["X"]=1;
20128
20129 // Note: Some Emscripten settings will significantly limit the speed of the generated code.
20130 // Note: Some Emscripten settings may limit the speed of the generated code.
20131 // Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
20132 var i64Math = null;
20133
20134
20135   function _memcpy(dest, src, num, align) {
20136       assert(num % 1 === 0, 'memcpy given ' + num + ' bytes to copy. Problem with quantum=1 corrections perhaps?');
20137       if (num >= 20 && src % 2 == dest % 2) {
20138         // This is unaligned, but quite large, and potentially alignable, so work hard to get to aligned settings
20139         if (src % 4 == dest % 4) {
20140           var stop = src + num;
20141           while (src % 4) { // no need to check for stop, since we have large num
20142             HEAP8[dest++] = HEAP8[src++];
20143           }
20144           var src4 = src >> 2, dest4 = dest >> 2, stop4 = stop >> 2;
20145           while (src4 < stop4) {
20146             HEAP32[dest4++] = HEAP32[src4++];
20147           }
20148           src = src4 << 2;
20149           dest = dest4 << 2;
20150           while (src < stop) {
20151             HEAP8[dest++] = HEAP8[src++];
20152           }
20153         } else {
20154           var stop = src + num;
20155           if (src % 2) { // no need to check for stop, since we have large num
20156             HEAP8[dest++] = HEAP8[src++];
20157           }
20158           var src2 = src >> 1, dest2 = dest >> 1, stop2 = stop >> 1;
20159           while (src2 < stop2) {
20160             HEAP16[dest2++] = HEAP16[src2++];
20161           }
20162           src = src2 << 1;
20163           dest = dest2 << 1;
20164           if (src < stop) {
20165             HEAP8[dest++] = HEAP8[src++];
20166           }
20167         }
20168       } else {
20169         while (num--) {
20170           HEAP8[dest++] = HEAP8[src++];
20171         }
20172       }
20173     }var _llvm_memcpy_p0i8_p0i8_i32=_memcpy;
20174 var _util_memory_a; // stub for _util_memory_a
20175 var _util_memory_d; // stub for _util_memory_d
20176 var _util_fopen; // stub for _util_fopen
20177
20178
20179
20180   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};
20181
20182   function ___setErrNo(value) {
20183       // For convenient setting and returning of errno.
20184       if (!___setErrNo.ret) ___setErrNo.ret = allocate([0], 'i32', ALLOC_STATIC);
20185       HEAP32[((___setErrNo.ret)>>2)]=value
20186       return value;
20187     }
20188
20189   var _stdin=0;
20190
20191   var _stdout=0;
20192
20193   var _stderr=0;
20194
20195   var __impure_ptr=0;var FS={currentPath:"/",nextInode:2,streams:[null],checkStreams:function () {
20196         for (var i in FS.streams) assert(i >= 0 && i < FS.streams.length); // no keys not in dense span
20197         for (var i = 0; i < FS.streams.length; i++) assert(typeof FS.streams[i] == 'object'); // no non-null holes in dense span
20198       },ignorePermissions:true,joinPath:function (parts, forceRelative) {
20199         var ret = parts[0];
20200         for (var i = 1; i < parts.length; i++) {
20201           if (ret[ret.length-1] != '/') ret += '/';
20202           ret += parts[i];
20203         }
20204         if (forceRelative && ret[0] == '/') ret = ret.substr(1);
20205         return ret;
20206       },absolutePath:function (relative, base) {
20207         if (typeof relative !== 'string') return null;
20208         if (base === undefined) base = FS.currentPath;
20209         if (relative && relative[0] == '/') base = '';
20210         var full = base + '/' + relative;
20211         var parts = full.split('/').reverse();
20212         var absolute = [''];
20213         while (parts.length) {
20214           var part = parts.pop();
20215           if (part == '' || part == '.') {
20216             // Nothing.
20217           } else if (part == '..') {
20218             if (absolute.length > 1) absolute.pop();
20219           } else {
20220             absolute.push(part);
20221           }
20222         }
20223         return absolute.length == 1 ? '/' : absolute.join('/');
20224       },analyzePath:function (path, dontResolveLastLink, linksVisited) {
20225         var ret = {
20226           isRoot: false,
20227           exists: false,
20228           error: 0,
20229           name: null,
20230           path: null,
20231           object: null,
20232           parentExists: false,
20233           parentPath: null,
20234           parentObject: null
20235         };
20236         path = FS.absolutePath(path);
20237         if (path == '/') {
20238           ret.isRoot = true;
20239           ret.exists = ret.parentExists = true;
20240           ret.name = '/';
20241           ret.path = ret.parentPath = '/';
20242           ret.object = ret.parentObject = FS.root;
20243         } else if (path !== null) {
20244           linksVisited = linksVisited || 0;
20245           path = path.slice(1).split('/');
20246           var current = FS.root;
20247           var traversed = [''];
20248           while (path.length) {
20249             if (path.length == 1 && current.isFolder) {
20250               ret.parentExists = true;
20251               ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/');
20252               ret.parentObject = current;
20253               ret.name = path[0];
20254             }
20255             var target = path.shift();
20256             if (!current.isFolder) {
20257               ret.error = ERRNO_CODES.ENOTDIR;
20258               break;
20259             } else if (!current.read) {
20260               ret.error = ERRNO_CODES.EACCES;
20261               break;
20262             } else if (!current.contents.hasOwnProperty(target)) {
20263               ret.error = ERRNO_CODES.ENOENT;
20264               break;
20265             }
20266             current = current.contents[target];
20267             if (current.link && !(dontResolveLastLink && path.length == 0)) {
20268               if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX.
20269                 ret.error = ERRNO_CODES.ELOOP;
20270                 break;
20271               }
20272               var link = FS.absolutePath(current.link, traversed.join('/'));
20273               ret = FS.analyzePath([link].concat(path).join('/'),
20274                                    dontResolveLastLink, linksVisited + 1);
20275               return ret;
20276             }
20277             traversed.push(target);
20278             if (path.length == 0) {
20279               ret.exists = true;
20280               ret.path = traversed.join('/');
20281               ret.object = current;
20282             }
20283           }
20284         }
20285         return ret;
20286       },findObject:function (path, dontResolveLastLink) {
20287         FS.ensureRoot();
20288         var ret = FS.analyzePath(path, dontResolveLastLink);
20289         if (ret.exists) {
20290           return ret.object;
20291         } else {
20292           ___setErrNo(ret.error);
20293           return null;
20294         }
20295       },createObject:function (parent, name, properties, canRead, canWrite) {
20296         if (!parent) parent = '/';
20297         if (typeof parent === 'string') parent = FS.findObject(parent);
20298
20299         if (!parent) {
20300           ___setErrNo(ERRNO_CODES.EACCES);
20301           throw new Error('Parent path must exist.');
20302         }
20303         if (!parent.isFolder) {
20304           ___setErrNo(ERRNO_CODES.ENOTDIR);
20305           throw new Error('Parent must be a folder.');
20306         }
20307         if (!parent.write && !FS.ignorePermissions) {
20308           ___setErrNo(ERRNO_CODES.EACCES);
20309           throw new Error('Parent folder must be writeable.');
20310         }
20311         if (!name || name == '.' || name == '..') {
20312           ___setErrNo(ERRNO_CODES.ENOENT);
20313           throw new Error('Name must not be empty.');
20314         }
20315         if (parent.contents.hasOwnProperty(name)) {
20316           ___setErrNo(ERRNO_CODES.EEXIST);
20317           throw new Error("Can't overwrite object.");
20318         }
20319
20320         parent.contents[name] = {
20321           read: canRead === undefined ? true : canRead,
20322           write: canWrite === undefined ? false : canWrite,
20323           timestamp: Date.now(),
20324           inodeNumber: FS.nextInode++
20325         };
20326         for (var key in properties) {
20327           if (properties.hasOwnProperty(key)) {
20328             parent.contents[name][key] = properties[key];
20329           }
20330         }
20331
20332         return parent.contents[name];
20333       },createFolder:function (parent, name, canRead, canWrite) {
20334         var properties = {isFolder: true, isDevice: false, contents: {}};
20335         return FS.createObject(parent, name, properties, canRead, canWrite);
20336       },createPath:function (parent, path, canRead, canWrite) {
20337         var current = FS.findObject(parent);
20338         if (current === null) throw new Error('Invalid parent.');
20339         path = path.split('/').reverse();
20340         while (path.length) {
20341           var part = path.pop();
20342           if (!part) continue;
20343           if (!current.contents.hasOwnProperty(part)) {
20344             FS.createFolder(current, part, canRead, canWrite);
20345           }
20346           current = current.contents[part];
20347         }
20348         return current;
20349       },createFile:function (parent, name, properties, canRead, canWrite) {
20350         properties.isFolder = false;
20351         return FS.createObject(parent, name, properties, canRead, canWrite);
20352       },createDataFile:function (parent, name, data, canRead, canWrite) {
20353         if (typeof data === 'string') {
20354           var dataArray = new Array(data.length);
20355           for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i);
20356           data = dataArray;
20357         }
20358         var properties = {
20359           isDevice: false,
20360           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
20361         };
20362         return FS.createFile(parent, name, properties, canRead, canWrite);
20363       },createLazyFile:function (parent, name, url, canRead, canWrite) {
20364
20365         if (typeof XMLHttpRequest !== 'undefined') {
20366           if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
20367           // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
20368           var LazyUint8Array = function(chunkSize, length) {
20369             this.length = length;
20370             this.chunkSize = chunkSize;
20371             this.chunks = []; // Loaded chunks. Index is the chunk number
20372           }
20373           LazyUint8Array.prototype.get = function(idx) {
20374             if (idx > this.length-1 || idx < 0) {
20375               return undefined;
20376             }
20377             var chunkOffset = idx % chunkSize;
20378             var chunkNum = Math.floor(idx / chunkSize);
20379             return this.getter(chunkNum)[chunkOffset];
20380           }
20381           LazyUint8Array.prototype.setDataGetter = function(getter) {
20382             this.getter = getter;
20383           }
20384
20385           // Find length
20386           var xhr = new XMLHttpRequest();
20387           xhr.open('HEAD', url, false);
20388           xhr.send(null);
20389           if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
20390           var datalength = Number(xhr.getResponseHeader("Content-length"));
20391           var header;
20392           var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
20393           var chunkSize = 1024*1024; // Chunk size in bytes
20394           if (!hasByteServing) chunkSize = datalength;
20395
20396           // Function to get a range from the remote URL.
20397           var doXHR = (function(from, to) {
20398             if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
20399             if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
20400
20401             // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
20402             var xhr = new XMLHttpRequest();
20403             xhr.open('GET', url, false);
20404             if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
20405
20406             // Some hints to the browser that we want binary data.
20407             if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
20408             if (xhr.overrideMimeType) {
20409               xhr.overrideMimeType('text/plain; charset=x-user-defined');
20410             }
20411
20412             xhr.send(null);
20413             if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
20414             if (xhr.response !== undefined) {
20415               return new Uint8Array(xhr.response || []);
20416             } else {
20417               return intArrayFromString(xhr.responseText || '', true);
20418             }
20419           });
20420
20421           var lazyArray = new LazyUint8Array(chunkSize, datalength);
20422           lazyArray.setDataGetter(function(chunkNum) {
20423             var start = chunkNum * lazyArray.chunkSize;
20424             var end = (chunkNum+1) * lazyArray.chunkSize - 1; // including this byte
20425             end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
20426             if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
20427               lazyArray.chunks[chunkNum] = doXHR(start, end);
20428             }
20429             if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
20430             return lazyArray.chunks[chunkNum];
20431           });
20432           var properties = { isDevice: false, contents: lazyArray };
20433         } else {
20434           var properties = { isDevice: false, url: url };
20435         }
20436
20437         return FS.createFile(parent, name, properties, canRead, canWrite);
20438       },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) {
20439         Browser.ensureObjects();
20440         var fullname = FS.joinPath([parent, name], true);
20441         function processData(byteArray) {
20442           function finish(byteArray) {
20443             if (!dontCreateFile) {
20444               FS.createDataFile(parent, name, byteArray, canRead, canWrite);
20445             }
20446             if (onload) onload();
20447             removeRunDependency('cp ' + fullname);
20448           }
20449           var handled = false;
20450           Module['preloadPlugins'].forEach(function(plugin) {
20451             if (handled) return;
20452             if (plugin['canHandle'](fullname)) {
20453               plugin['handle'](byteArray, fullname, finish, function() {
20454                 if (onerror) onerror();
20455                 removeRunDependency('cp ' + fullname);
20456               });
20457               handled = true;
20458             }
20459           });
20460           if (!handled) finish(byteArray);
20461         }
20462         addRunDependency('cp ' + fullname);
20463         if (typeof url == 'string') {
20464           Browser.asyncLoad(url, function(byteArray) {
20465             processData(byteArray);
20466           }, onerror);
20467         } else {
20468           processData(url);
20469         }
20470       },createLink:function (parent, name, target, canRead, canWrite) {
20471         var properties = {isDevice: false, link: target};
20472         return FS.createFile(parent, name, properties, canRead, canWrite);
20473       },createDevice:function (parent, name, input, output) {
20474         if (!(input || output)) {
20475           throw new Error('A device must have at least one callback defined.');
20476         }
20477         var ops = {isDevice: true, input: input, output: output};
20478         return FS.createFile(parent, name, ops, Boolean(input), Boolean(output));
20479       },forceLoadFile:function (obj) {
20480         if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
20481         var success = true;
20482         if (typeof XMLHttpRequest !== 'undefined') {
20483           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.");
20484         } else if (Module['read']) {
20485           // Command-line.
20486           try {
20487             // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
20488             //          read() will try to parse UTF8.
20489             obj.contents = intArrayFromString(Module['read'](obj.url), true);
20490           } catch (e) {
20491             success = false;
20492           }
20493         } else {
20494           throw new Error('Cannot load without read() or XMLHttpRequest.');
20495         }
20496         if (!success) ___setErrNo(ERRNO_CODES.EIO);
20497         return success;
20498       },ensureRoot:function () {
20499         if (FS.root) return;
20500         // The main file system tree. All the contents are inside this.
20501         FS.root = {
20502           read: true,
20503           write: true,
20504           isFolder: true,
20505           isDevice: false,
20506           timestamp: Date.now(),
20507           inodeNumber: 1,
20508           contents: {}
20509         };
20510       },init:function (input, output, error) {
20511         // Make sure we initialize only once.
20512         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)');
20513         FS.init.initialized = true;
20514
20515         FS.ensureRoot();
20516
20517         // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
20518         input = input || Module['stdin'];
20519         output = output || Module['stdout'];
20520         error = error || Module['stderr'];
20521
20522         // Default handlers.
20523         var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true;
20524         if (!input) {
20525           stdinOverridden = false;
20526           input = function() {
20527             if (!input.cache || !input.cache.length) {
20528               var result;
20529               if (typeof window != 'undefined' &&
20530                   typeof window.prompt == 'function') {
20531                 // Browser.
20532                 result = window.prompt('Input: ');
20533                 if (result === null) result = String.fromCharCode(0); // cancel ==> EOF
20534               } else if (typeof readline == 'function') {
20535                 // Command line.
20536                 result = readline();
20537               }
20538               if (!result) result = '';
20539               input.cache = intArrayFromString(result + '\n', true);
20540             }
20541             return input.cache.shift();
20542           };
20543         }
20544         var utf8 = new Runtime.UTF8Processor();
20545         function simpleOutput(val) {
20546           if (val === null || val === '\n'.charCodeAt(0)) {
20547             output.printer(output.buffer.join(''));
20548             output.buffer = [];
20549           } else {
20550             output.buffer.push(utf8.processCChar(val));
20551           }
20552         }
20553         if (!output) {
20554           stdoutOverridden = false;
20555           output = simpleOutput;
20556         }
20557         if (!output.printer) output.printer = Module['print'];
20558         if (!output.buffer) output.buffer = [];
20559         if (!error) {
20560           stderrOverridden = false;
20561           error = simpleOutput;
20562         }
20563         if (!error.printer) error.printer = Module['print'];
20564         if (!error.buffer) error.buffer = [];
20565
20566         // Create the temporary folder, if not already created
20567         try {
20568           FS.createFolder('/', 'tmp', true, true);
20569         } catch(e) {}
20570
20571         // Create the I/O devices.
20572         var devFolder = FS.createFolder('/', 'dev', true, true);
20573         var stdin = FS.createDevice(devFolder, 'stdin', input);
20574         var stdout = FS.createDevice(devFolder, 'stdout', null, output);
20575         var stderr = FS.createDevice(devFolder, 'stderr', null, error);
20576         FS.createDevice(devFolder, 'tty', input, output);
20577
20578         // Create default streams.
20579         FS.streams[1] = {
20580           path: '/dev/stdin',
20581           object: stdin,
20582           position: 0,
20583           isRead: true,
20584           isWrite: false,
20585           isAppend: false,
20586           isTerminal: !stdinOverridden,
20587           error: false,
20588           eof: false,
20589           ungotten: []
20590         };
20591         FS.streams[2] = {
20592           path: '/dev/stdout',
20593           object: stdout,
20594           position: 0,
20595           isRead: false,
20596           isWrite: true,
20597           isAppend: false,
20598           isTerminal: !stdoutOverridden,
20599           error: false,
20600           eof: false,
20601           ungotten: []
20602         };
20603         FS.streams[3] = {
20604           path: '/dev/stderr',
20605           object: stderr,
20606           position: 0,
20607           isRead: false,
20608           isWrite: true,
20609           isAppend: false,
20610           isTerminal: !stderrOverridden,
20611           error: false,
20612           eof: false,
20613           ungotten: []
20614         };
20615         // Allocate these on the stack (and never free, we are called from ATINIT or earlier), to keep their locations low
20616         _stdin = allocate([1], 'void*', ALLOC_STACK);
20617         _stdout = allocate([2], 'void*', ALLOC_STACK);
20618         _stderr = allocate([3], 'void*', ALLOC_STACK);
20619
20620         // Other system paths
20621         FS.createPath('/', 'dev/shm/tmp', true, true); // temp files
20622
20623         // Newlib initialization
20624         for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + 4; i++) {
20625           FS.streams[i] = null; // Make sure to keep FS.streams dense
20626         }
20627         FS.streams[_stdin] = FS.streams[1];
20628         FS.streams[_stdout] = FS.streams[2];
20629         FS.streams[_stderr] = FS.streams[3];
20630         FS.checkStreams();
20631         assert(FS.streams.length < 1024); // at this early stage, we should not have a large set of file descriptors - just a few
20632         __impure_ptr = allocate([ allocate(
20633           [0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0],
20634           'void*', ALLOC_STATIC) ], 'void*', ALLOC_STATIC);
20635       },quit:function () {
20636         if (!FS.init.initialized) return;
20637         // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed
20638         if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output('\n'.charCodeAt(0));
20639         if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output('\n'.charCodeAt(0));
20640       },standardizePath:function (path) {
20641         if (path.substr(0, 2) == './') path = path.substr(2);
20642         return path;
20643       },deleteFile:function (path) {
20644         var path = FS.analyzePath(path);
20645         if (!path.parentExists || !path.exists) {
20646           throw 'Invalid path ' + path;
20647         }
20648         delete path.parentObject.contents[path.name];
20649       }};
20650
20651
20652   function _pread(fildes, buf, nbyte, offset) {
20653       // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
20654       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
20655       var stream = FS.streams[fildes];
20656       if (!stream || stream.object.isDevice) {
20657         ___setErrNo(ERRNO_CODES.EBADF);
20658         return -1;
20659       } else if (!stream.isRead) {
20660         ___setErrNo(ERRNO_CODES.EACCES);
20661         return -1;
20662       } else if (stream.object.isFolder) {
20663         ___setErrNo(ERRNO_CODES.EISDIR);
20664         return -1;
20665       } else if (nbyte < 0 || offset < 0) {
20666         ___setErrNo(ERRNO_CODES.EINVAL);
20667         return -1;
20668       } else {
20669         var bytesRead = 0;
20670         while (stream.ungotten.length && nbyte > 0) {
20671           HEAP8[(buf++)]=stream.ungotten.pop()
20672           nbyte--;
20673           bytesRead++;
20674         }
20675         var contents = stream.object.contents;
20676         var size = Math.min(contents.length - offset, nbyte);
20677         if (contents.subarray || contents.slice) { // typed array or normal array
20678           for (var i = 0; i < size; i++) {
20679             HEAP8[((buf)+(i))]=contents[offset + i]
20680           }
20681         } else {
20682           for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
20683             HEAP8[((buf)+(i))]=contents.get(offset + i)
20684           }
20685         }
20686         bytesRead += size;
20687         return bytesRead;
20688       }
20689     }function _read(fildes, buf, nbyte) {
20690       // ssize_t read(int fildes, void *buf, size_t nbyte);
20691       // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
20692       var stream = FS.streams[fildes];
20693       if (!stream) {
20694         ___setErrNo(ERRNO_CODES.EBADF);
20695         return -1;
20696       } else if (!stream.isRead) {
20697         ___setErrNo(ERRNO_CODES.EACCES);
20698         return -1;
20699       } else if (nbyte < 0) {
20700         ___setErrNo(ERRNO_CODES.EINVAL);
20701         return -1;
20702       } else {
20703         var bytesRead;
20704         if (stream.object.isDevice) {
20705           if (stream.object.input) {
20706             bytesRead = 0;
20707             while (stream.ungotten.length && nbyte > 0) {
20708               HEAP8[(buf++)]=stream.ungotten.pop()
20709               nbyte--;
20710               bytesRead++;
20711             }
20712             for (var i = 0; i < nbyte; i++) {
20713               try {
20714                 var result = stream.object.input();
20715               } catch (e) {
20716                 ___setErrNo(ERRNO_CODES.EIO);
20717                 return -1;
20718               }
20719               if (result === null || result === undefined) break;
20720               bytesRead++;
20721               HEAP8[((buf)+(i))]=result
20722             }
20723             return bytesRead;
20724           } else {
20725             ___setErrNo(ERRNO_CODES.ENXIO);
20726             return -1;
20727           }
20728         } else {
20729           var ungotSize = stream.ungotten.length;
20730           bytesRead = _pread(fildes, buf, nbyte, stream.position);
20731           if (bytesRead != -1) {
20732             stream.position += (stream.ungotten.length - ungotSize) + bytesRead;
20733           }
20734           return bytesRead;
20735         }
20736       }
20737     }function _fread(ptr, size, nitems, stream) {
20738       // size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
20739       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html
20740       var bytesToRead = nitems * size;
20741       if (bytesToRead == 0) return 0;
20742       var bytesRead = _read(stream, ptr, bytesToRead);
20743       var streamObj = FS.streams[stream];
20744       if (bytesRead == -1) {
20745         if (streamObj) streamObj.error = true;
20746         return 0;
20747       } else {
20748         if (bytesRead < bytesToRead) streamObj.eof = true;
20749         return Math.floor(bytesRead / size);
20750       }
20751     }
20752
20753
20754   function _close(fildes) {
20755       // int close(int fildes);
20756       // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html
20757       if (FS.streams[fildes]) {
20758         if (FS.streams[fildes].currentEntry) {
20759           _free(FS.streams[fildes].currentEntry);
20760         }
20761         FS.streams[fildes] = null;
20762         return 0;
20763       } else {
20764         ___setErrNo(ERRNO_CODES.EBADF);
20765         return -1;
20766       }
20767     }
20768
20769   function _fsync(fildes) {
20770       // int fsync(int fildes);
20771       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html
20772       if (FS.streams[fildes]) {
20773         // We write directly to the file system, so there's nothing to do here.
20774         return 0;
20775       } else {
20776         ___setErrNo(ERRNO_CODES.EBADF);
20777         return -1;
20778       }
20779     }function _fclose(stream) {
20780       // int fclose(FILE *stream);
20781       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html
20782       _fsync(stream);
20783       return _close(stream);
20784     }
20785
20786
20787
20788
20789
20790   function _pwrite(fildes, buf, nbyte, offset) {
20791       // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
20792       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
20793       var stream = FS.streams[fildes];
20794       if (!stream || stream.object.isDevice) {
20795         ___setErrNo(ERRNO_CODES.EBADF);
20796         return -1;
20797       } else if (!stream.isWrite) {
20798         ___setErrNo(ERRNO_CODES.EACCES);
20799         return -1;
20800       } else if (stream.object.isFolder) {
20801         ___setErrNo(ERRNO_CODES.EISDIR);
20802         return -1;
20803       } else if (nbyte < 0 || offset < 0) {
20804         ___setErrNo(ERRNO_CODES.EINVAL);
20805         return -1;
20806       } else {
20807         var contents = stream.object.contents;
20808         while (contents.length < offset) contents.push(0);
20809         for (var i = 0; i < nbyte; i++) {
20810           contents[offset + i] = HEAPU8[((buf)+(i))];
20811         }
20812         stream.object.timestamp = Date.now();
20813         return i;
20814       }
20815     }function _write(fildes, buf, nbyte) {
20816       // ssize_t write(int fildes, const void *buf, size_t nbyte);
20817       // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
20818       var stream = FS.streams[fildes];
20819       if (!stream) {
20820         ___setErrNo(ERRNO_CODES.EBADF);
20821         return -1;
20822       } else if (!stream.isWrite) {
20823         ___setErrNo(ERRNO_CODES.EACCES);
20824         return -1;
20825       } else if (nbyte < 0) {
20826         ___setErrNo(ERRNO_CODES.EINVAL);
20827         return -1;
20828       } else {
20829         if (stream.object.isDevice) {
20830           if (stream.object.output) {
20831             for (var i = 0; i < nbyte; i++) {
20832               try {
20833                 stream.object.output(HEAP8[((buf)+(i))]);
20834               } catch (e) {
20835                 ___setErrNo(ERRNO_CODES.EIO);
20836                 return -1;
20837               }
20838             }
20839             stream.object.timestamp = Date.now();
20840             return i;
20841           } else {
20842             ___setErrNo(ERRNO_CODES.ENXIO);
20843             return -1;
20844           }
20845         } else {
20846           var bytesWritten = _pwrite(fildes, buf, nbyte, stream.position);
20847           if (bytesWritten != -1) stream.position += bytesWritten;
20848           return bytesWritten;
20849         }
20850       }
20851     }function _fwrite(ptr, size, nitems, stream) {
20852       // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
20853       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
20854       var bytesToWrite = nitems * size;
20855       if (bytesToWrite == 0) return 0;
20856       var bytesWritten = _write(stream, ptr, bytesToWrite);
20857       if (bytesWritten == -1) {
20858         if (FS.streams[stream]) FS.streams[stream].error = true;
20859         return 0;
20860       } else {
20861         return Math.floor(bytesWritten / size);
20862       }
20863     }
20864
20865   function __formatString(format, varargs) {
20866       var textIndex = format;
20867       var argIndex = 0;
20868       function getNextArg(type) {
20869         // NOTE: Explicitly ignoring type safety. Otherwise this fails:
20870         //       int x = 4; printf("%c\n", (char)x);
20871         var ret;
20872         if (type === 'double') {
20873           ret = (tempDoubleI32[0]=HEAP32[(((varargs)+(argIndex))>>2)],tempDoubleI32[1]=HEAP32[(((varargs)+((argIndex)+(4)))>>2)],tempDoubleF64[0]);
20874         } else if (type == 'i64') {
20875           ret = [HEAP32[(((varargs)+(argIndex))>>2)],
20876                  HEAP32[(((varargs)+(argIndex+4))>>2)]];
20877         } else {
20878           type = 'i32'; // varargs are always i32, i64, or double
20879           ret = HEAP32[(((varargs)+(argIndex))>>2)];
20880         }
20881         argIndex += Runtime.getNativeFieldSize(type);
20882         return ret;
20883       }
20884
20885       var ret = [];
20886       var curr, next, currArg;
20887       while(1) {
20888         var startTextIndex = textIndex;
20889         curr = HEAP8[(textIndex)];
20890         if (curr === 0) break;
20891         next = HEAP8[(textIndex+1)];
20892         if (curr == '%'.charCodeAt(0)) {
20893           // Handle flags.
20894           var flagAlwaysSigned = false;
20895           var flagLeftAlign = false;
20896           var flagAlternative = false;
20897           var flagZeroPad = false;
20898           flagsLoop: while (1) {
20899             switch (next) {
20900               case '+'.charCodeAt(0):
20901                 flagAlwaysSigned = true;
20902                 break;
20903               case '-'.charCodeAt(0):
20904                 flagLeftAlign = true;
20905                 break;
20906               case '#'.charCodeAt(0):
20907                 flagAlternative = true;
20908                 break;
20909               case '0'.charCodeAt(0):
20910                 if (flagZeroPad) {
20911                   break flagsLoop;
20912                 } else {
20913                   flagZeroPad = true;
20914                   break;
20915                 }
20916               default:
20917                 break flagsLoop;
20918             }
20919             textIndex++;
20920             next = HEAP8[(textIndex+1)];
20921           }
20922
20923           // Handle width.
20924           var width = 0;
20925           if (next == '*'.charCodeAt(0)) {
20926             width = getNextArg('i32');
20927             textIndex++;
20928             next = HEAP8[(textIndex+1)];
20929           } else {
20930             while (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) {
20931               width = width * 10 + (next - '0'.charCodeAt(0));
20932               textIndex++;
20933               next = HEAP8[(textIndex+1)];
20934             }
20935           }
20936
20937           // Handle precision.
20938           var precisionSet = false;
20939           if (next == '.'.charCodeAt(0)) {
20940             var precision = 0;
20941             precisionSet = true;
20942             textIndex++;
20943             next = HEAP8[(textIndex+1)];
20944             if (next == '*'.charCodeAt(0)) {
20945               precision = getNextArg('i32');
20946               textIndex++;
20947             } else {
20948               while(1) {
20949                 var precisionChr = HEAP8[(textIndex+1)];
20950                 if (precisionChr < '0'.charCodeAt(0) ||
20951                     precisionChr > '9'.charCodeAt(0)) break;
20952                 precision = precision * 10 + (precisionChr - '0'.charCodeAt(0));
20953                 textIndex++;
20954               }
20955             }
20956             next = HEAP8[(textIndex+1)];
20957           } else {
20958             var precision = 6; // Standard default.
20959           }
20960
20961           // Handle integer sizes. WARNING: These assume a 32-bit architecture!
20962           var argSize;
20963           switch (String.fromCharCode(next)) {
20964             case 'h':
20965               var nextNext = HEAP8[(textIndex+2)];
20966               if (nextNext == 'h'.charCodeAt(0)) {
20967                 textIndex++;
20968                 argSize = 1; // char (actually i32 in varargs)
20969               } else {
20970                 argSize = 2; // short (actually i32 in varargs)
20971               }
20972               break;
20973             case 'l':
20974               var nextNext = HEAP8[(textIndex+2)];
20975               if (nextNext == 'l'.charCodeAt(0)) {
20976                 textIndex++;
20977                 argSize = 8; // long long
20978               } else {
20979                 argSize = 4; // long
20980               }
20981               break;
20982             case 'L': // long long
20983             case 'q': // int64_t
20984             case 'j': // intmax_t
20985               argSize = 8;
20986               break;
20987             case 'z': // size_t
20988             case 't': // ptrdiff_t
20989             case 'I': // signed ptrdiff_t or unsigned size_t
20990               argSize = 4;
20991               break;
20992             default:
20993               argSize = null;
20994           }
20995           if (argSize) textIndex++;
20996           next = HEAP8[(textIndex+1)];
20997
20998           // Handle type specifier.
20999           if (['d', 'i', 'u', 'o', 'x', 'X', 'p'].indexOf(String.fromCharCode(next)) != -1) {
21000             // Integer.
21001             var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0);
21002             argSize = argSize || 4;
21003             var currArg = getNextArg('i' + (argSize * 8));
21004             var origArg = currArg;
21005             var argText;
21006             // Flatten i64-1 [low, high] into a (slightly rounded) double
21007             if (argSize == 8) {
21008               currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0));
21009             }
21010             // Truncate to requested size.
21011             if (argSize <= 4) {
21012               var limit = Math.pow(256, argSize) - 1;
21013               currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
21014             }
21015             // Format the number.
21016             var currAbsArg = Math.abs(currArg);
21017             var prefix = '';
21018             if (next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0)) {
21019               if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1]); else
21020               argText = reSign(currArg, 8 * argSize, 1).toString(10);
21021             } else if (next == 'u'.charCodeAt(0)) {
21022               if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
21023               argText = unSign(currArg, 8 * argSize, 1).toString(10);
21024               currArg = Math.abs(currArg);
21025             } else if (next == 'o'.charCodeAt(0)) {
21026               argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
21027             } else if (next == 'x'.charCodeAt(0) || next == 'X'.charCodeAt(0)) {
21028               prefix = flagAlternative ? '0x' : '';
21029               if (currArg < 0) {
21030                 // Represent negative numbers in hex as 2's complement.
21031                 currArg = -currArg;
21032                 argText = (currAbsArg - 1).toString(16);
21033                 var buffer = [];
21034                 for (var i = 0; i < argText.length; i++) {
21035                   buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
21036                 }
21037                 argText = buffer.join('');
21038                 while (argText.length < argSize * 2) argText = 'f' + argText;
21039               } else {
21040                 argText = currAbsArg.toString(16);
21041               }
21042               if (next == 'X'.charCodeAt(0)) {
21043                 prefix = prefix.toUpperCase();
21044                 argText = argText.toUpperCase();
21045               }
21046             } else if (next == 'p'.charCodeAt(0)) {
21047               if (currAbsArg === 0) {
21048                 argText = '(nil)';
21049               } else {
21050                 prefix = '0x';
21051                 argText = currAbsArg.toString(16);
21052               }
21053             }
21054             if (precisionSet) {
21055               while (argText.length < precision) {
21056                 argText = '0' + argText;
21057               }
21058             }
21059
21060             // Add sign if needed
21061             if (flagAlwaysSigned) {
21062               if (currArg < 0) {
21063                 prefix = '-' + prefix;
21064               } else {
21065                 prefix = '+' + prefix;
21066               }
21067             }
21068
21069             // Add padding.
21070             while (prefix.length + argText.length < width) {
21071               if (flagLeftAlign) {
21072                 argText += ' ';
21073               } else {
21074                 if (flagZeroPad) {
21075                   argText = '0' + argText;
21076                 } else {
21077                   prefix = ' ' + prefix;
21078                 }
21079               }
21080             }
21081
21082             // Insert the result into the buffer.
21083             argText = prefix + argText;
21084             argText.split('').forEach(function(chr) {
21085               ret.push(chr.charCodeAt(0));
21086             });
21087           } else if (['f', 'F', 'e', 'E', 'g', 'G'].indexOf(String.fromCharCode(next)) != -1) {
21088             // Float.
21089             var currArg = getNextArg('double');
21090             var argText;
21091
21092             if (isNaN(currArg)) {
21093               argText = 'nan';
21094               flagZeroPad = false;
21095             } else if (!isFinite(currArg)) {
21096               argText = (currArg < 0 ? '-' : '') + 'inf';
21097               flagZeroPad = false;
21098             } else {
21099               var isGeneral = false;
21100               var effectivePrecision = Math.min(precision, 20);
21101
21102               // Convert g/G to f/F or e/E, as per:
21103               // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
21104               if (next == 'g'.charCodeAt(0) || next == 'G'.charCodeAt(0)) {
21105                 isGeneral = true;
21106                 precision = precision || 1;
21107                 var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
21108                 if (precision > exponent && exponent >= -4) {
21109                   next = ((next == 'g'.charCodeAt(0)) ? 'f' : 'F').charCodeAt(0);
21110                   precision -= exponent + 1;
21111                 } else {
21112                   next = ((next == 'g'.charCodeAt(0)) ? 'e' : 'E').charCodeAt(0);
21113                   precision--;
21114                 }
21115                 effectivePrecision = Math.min(precision, 20);
21116               }
21117
21118               if (next == 'e'.charCodeAt(0) || next == 'E'.charCodeAt(0)) {
21119                 argText = currArg.toExponential(effectivePrecision);
21120                 // Make sure the exponent has at least 2 digits.
21121                 if (/[eE][-+]\d$/.test(argText)) {
21122                   argText = argText.slice(0, -1) + '0' + argText.slice(-1);
21123                 }
21124               } else if (next == 'f'.charCodeAt(0) || next == 'F'.charCodeAt(0)) {
21125                 argText = currArg.toFixed(effectivePrecision);
21126               }
21127
21128               var parts = argText.split('e');
21129               if (isGeneral && !flagAlternative) {
21130                 // Discard trailing zeros and periods.
21131                 while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
21132                        (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
21133                   parts[0] = parts[0].slice(0, -1);
21134                 }
21135               } else {
21136                 // Make sure we have a period in alternative mode.
21137                 if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
21138                 // Zero pad until required precision.
21139                 while (precision > effectivePrecision++) parts[0] += '0';
21140               }
21141               argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
21142
21143               // Capitalize 'E' if needed.
21144               if (next == 'E'.charCodeAt(0)) argText = argText.toUpperCase();
21145
21146               // Add sign.
21147               if (flagAlwaysSigned && currArg >= 0) {
21148                 argText = '+' + argText;
21149               }
21150             }
21151
21152             // Add padding.
21153             while (argText.length < width) {
21154               if (flagLeftAlign) {
21155                 argText += ' ';
21156               } else {
21157                 if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
21158                   argText = argText[0] + '0' + argText.slice(1);
21159                 } else {
21160                   argText = (flagZeroPad ? '0' : ' ') + argText;
21161                 }
21162               }
21163             }
21164
21165             // Adjust case.
21166             if (next < 'a'.charCodeAt(0)) argText = argText.toUpperCase();
21167
21168             // Insert the result into the buffer.
21169             argText.split('').forEach(function(chr) {
21170               ret.push(chr.charCodeAt(0));
21171             });
21172           } else if (next == 's'.charCodeAt(0)) {
21173             // String.
21174             var arg = getNextArg('i8*') || nullString;
21175             var argLength = String_len(arg);
21176             if (precisionSet) argLength = Math.min(argLength, precision);
21177             if (!flagLeftAlign) {
21178               while (argLength < width--) {
21179                 ret.push(' '.charCodeAt(0));
21180               }
21181             }
21182             for (var i = 0; i < argLength; i++) {
21183               ret.push(HEAPU8[(arg++)]);
21184             }
21185             if (flagLeftAlign) {
21186               while (argLength < width--) {
21187                 ret.push(' '.charCodeAt(0));
21188               }
21189             }
21190           } else if (next == 'c'.charCodeAt(0)) {
21191             // Character.
21192             if (flagLeftAlign) ret.push(getNextArg('i8'));
21193             while (--width > 0) {
21194               ret.push(' '.charCodeAt(0));
21195             }
21196             if (!flagLeftAlign) ret.push(getNextArg('i8'));
21197           } else if (next == 'n'.charCodeAt(0)) {
21198             // Write the length written so far to the next parameter.
21199             var ptr = getNextArg('i32*');
21200             HEAP32[((ptr)>>2)]=ret.length
21201           } else if (next == '%'.charCodeAt(0)) {
21202             // Literal percent sign.
21203             ret.push(curr);
21204           } else {
21205             // Unknown specifiers remain untouched.
21206             for (var i = startTextIndex; i < textIndex + 2; i++) {
21207               ret.push(HEAP8[(i)]);
21208             }
21209           }
21210           textIndex += 2;
21211           // TODO: Support a/A (hex float) and m (last error) specifiers.
21212           // TODO: Support %1${specifier} for arg selection.
21213         } else {
21214           ret.push(curr);
21215           textIndex += 1;
21216         }
21217       }
21218       return ret;
21219     }function _fprintf(stream, format, varargs) {
21220       // int fprintf(FILE *restrict stream, const char *restrict format, ...);
21221       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
21222       var result = __formatString(format, varargs);
21223       var stack = Runtime.stackSave();
21224       var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
21225       Runtime.stackRestore(stack);
21226       return ret;
21227     }function _printf(format, varargs) {
21228       // int printf(const char *restrict format, ...);
21229       // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
21230       var stdout = HEAP32[((_stdout)>>2)];
21231       return _fprintf(stdout, format, varargs);
21232     }
21233
21234
21235   function _memset(ptr, value, num, align) {
21236       // TODO: make these settings, and in memcpy, {{'s
21237       if (num >= 20) {
21238         // This is unaligned, but quite large, so work hard to get to aligned settings
21239         var stop = ptr + num;
21240         while (ptr % 4) { // no need to check for stop, since we have large num
21241           HEAP8[ptr++] = value;
21242         }
21243         if (value < 0) value += 256; // make it unsigned
21244         var ptr4 = ptr >> 2, stop4 = stop >> 2, value4 = value | (value << 8) | (value << 16) | (value << 24);
21245         while (ptr4 < stop4) {
21246           HEAP32[ptr4++] = value4;
21247         }
21248         ptr = ptr4 << 2;
21249         while (ptr < stop) {
21250           HEAP8[ptr++] = value;
21251         }
21252       } else {
21253         while (num--) {
21254           HEAP8[ptr++] = value;
21255         }
21256       }
21257     }var _llvm_memset_p0i8_i32=_memset;
21258 var _util_strdup; // stub for _util_strdup
21259
21260
21261   function _lseek(fildes, offset, whence) {
21262       // off_t lseek(int fildes, off_t offset, int whence);
21263       // http://pubs.opengroup.org/onlinepubs/000095399/functions/lseek.html
21264       if (FS.streams[fildes] && !FS.streams[fildes].object.isDevice) {
21265         var stream = FS.streams[fildes];
21266         var position = offset;
21267         if (whence === 1) {  // SEEK_CUR.
21268           position += stream.position;
21269         } else if (whence === 2) {  // SEEK_END.
21270           position += stream.object.contents.length;
21271         }
21272         if (position < 0) {
21273           ___setErrNo(ERRNO_CODES.EINVAL);
21274           return -1;
21275         } else {
21276           stream.ungotten = [];
21277           stream.position = position;
21278           return position;
21279         }
21280       } else {
21281         ___setErrNo(ERRNO_CODES.EBADF);
21282         return -1;
21283       }
21284     }function _fseek(stream, offset, whence) {
21285       // int fseek(FILE *stream, long offset, int whence);
21286       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fseek.html
21287       var ret = _lseek(stream, offset, whence);
21288       if (ret == -1) {
21289         return -1;
21290       } else {
21291         FS.streams[stream].eof = false;
21292         return 0;
21293       }
21294     }
21295
21296   function _strlen(ptr) {
21297       return String_len(ptr);
21298     }
21299
21300
21301   function _strncmp(px, py, n) {
21302       var i = 0;
21303       while (i < n) {
21304         var x = HEAPU8[((px)+(i))];
21305         var y = HEAPU8[((py)+(i))];
21306         if (x == y && x == 0) return 0;
21307         if (x == 0) return -1;
21308         if (y == 0) return 1;
21309         if (x == y) {
21310           i ++;
21311           continue;
21312         } else {
21313           return x > y ? 1 : -1;
21314         }
21315       }
21316       return 0;
21317     }function _strcmp(px, py) {
21318       return _strncmp(px, py, TOTAL_MEMORY);
21319     }
21320
21321   function _fflush(stream) {
21322       // int fflush(FILE *stream);
21323       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
21324       var flush = function(filedes) {
21325         // Right now we write all data directly, except for output devices.
21326         if (FS.streams[filedes] && FS.streams[filedes].object.output) {
21327           if (!FS.streams[filedes].isTerminal) { // don't flush terminals, it would cause a \n to also appear
21328             FS.streams[filedes].object.output(null);
21329           }
21330         }
21331       };
21332       try {
21333         if (stream === 0) {
21334           for (var i = 0; i < FS.streams.length; i++) if (FS.streams[i]) flush(i);
21335         } else {
21336           flush(stream);
21337         }
21338         return 0;
21339       } catch (e) {
21340         ___setErrNo(ERRNO_CODES.EIO);
21341         return -1;
21342       }
21343     }
21344
21345
21346   function _fputc(c, stream) {
21347       // int fputc(int c, FILE *stream);
21348       // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
21349       var chr = unSign(c & 0xFF);
21350       HEAP8[(_fputc.ret)]=chr
21351       var ret = _write(stream, _fputc.ret, 1);
21352       if (ret == -1) {
21353         if (FS.streams[stream]) FS.streams[stream].error = true;
21354         return -1;
21355       } else {
21356         return chr;
21357       }
21358     }var _putc=_fputc;
21359
21360
21361   function __exit(status) {
21362       // void _exit(int status);
21363       // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
21364
21365
21366       exitRuntime();
21367       ABORT = true;
21368
21369       throw 'exit(' + status + ') called, at ' + new Error().stack;
21370     }function _exit(status) {
21371       __exit(status);
21372     }
21373 var _llvm_va_start; // stub for _llvm_va_start
21374
21375   var _vprintf=_printf;
21376
21377   function _llvm_va_end() {}
21378
21379
21380   function ___errno_location() {
21381       return ___setErrNo.ret;
21382     }var ___errno=___errno_location;
21383
21384
21385
21386   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) {
21387       if (errnum in ERRNO_MESSAGES) {
21388         if (ERRNO_MESSAGES[errnum].length > buflen - 1) {
21389           return ___setErrNo(ERRNO_CODES.ERANGE);
21390         } else {
21391           var msg = ERRNO_MESSAGES[errnum];
21392           for (var i = 0; i < msg.length; i++) {
21393             HEAP8[((strerrbuf)+(i))]=msg.charCodeAt(i)
21394           }
21395           HEAP8[((strerrbuf)+(i))]=0
21396           return 0;
21397         }
21398       } else {
21399         return ___setErrNo(ERRNO_CODES.EINVAL);
21400       }
21401     }function _strerror(errnum) {
21402       if (!_strerror.buffer) _strerror.buffer = _malloc(256);
21403       _strerror_r(errnum, _strerror.buffer, 256);
21404       return _strerror.buffer;
21405     }
21406
21407
21408
21409   function _malloc(bytes) {
21410       /* Over-allocate to make sure it is byte-aligned by 8.
21411        * This will leak memory, but this is only the dummy
21412        * implementation (replaced by dlmalloc normally) so
21413        * not an issue.
21414        */
21415       ptr = Runtime.staticAlloc(bytes + 8);
21416       return (ptr+8) & 0xFFFFFFF8;
21417     }
21418   Module["_malloc"] = _malloc;
21419
21420   function _free(){}
21421   Module["_free"] = _free;
21422
21423   var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false,queue:[],pause:function () {
21424           Browser.mainLoop.shouldPause = true;
21425         },resume:function () {
21426           if (Browser.mainLoop.paused) {
21427             Browser.mainLoop.paused = false;
21428             Browser.mainLoop.scheduler();
21429           }
21430           Browser.mainLoop.shouldPause = false;
21431         },updateStatus:function () {
21432           if (Module['setStatus']) {
21433             var message = Module['statusMessage'] || 'Please wait...';
21434             var remaining = Browser.mainLoop.remainingBlockers;
21435             var expected = Browser.mainLoop.expectedBlockers;
21436             if (remaining) {
21437               if (remaining < expected) {
21438                 Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
21439               } else {
21440                 Module['setStatus'](message);
21441               }
21442             } else {
21443               Module['setStatus']('');
21444             }
21445           }
21446         }},pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],ensureObjects:function () {
21447         if (Browser.ensured) return;
21448         Browser.ensured = true;
21449         try {
21450           new Blob();
21451           Browser.hasBlobConstructor = true;
21452         } catch(e) {
21453           Browser.hasBlobConstructor = false;
21454           console.log("warning: no blob constructor, cannot create blobs with mimetypes");
21455         }
21456         Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
21457         Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : console.log("warning: cannot create object URLs");
21458
21459         // Support for plugins that can process preloaded files. You can add more of these to
21460         // your app by creating and appending to Module.preloadPlugins.
21461         //
21462         // Each plugin is asked if it can handle a file based on the file's name. If it can,
21463         // it is given the file's raw data. When it is done, it calls a callback with the file's
21464         // (possibly modified) data. For example, a plugin might decompress a file, or it
21465         // might create some side data structure for use later (like an Image element, etc.).
21466
21467         function getMimetype(name) {
21468           return {
21469             'jpg': 'image/jpeg',
21470             'png': 'image/png',
21471             'bmp': 'image/bmp',
21472             'ogg': 'audio/ogg',
21473             'wav': 'audio/wav',
21474             'mp3': 'audio/mpeg'
21475           }[name.substr(-3)];
21476           return ret;
21477         }
21478
21479         if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
21480
21481         var imagePlugin = {};
21482         imagePlugin['canHandle'] = function(name) {
21483           return name.substr(-4) in { '.jpg': 1, '.png': 1, '.bmp': 1 };
21484         };
21485         imagePlugin['handle'] = function(byteArray, name, onload, onerror) {
21486           var b = null;
21487           if (Browser.hasBlobConstructor) {
21488             try {
21489               b = new Blob([byteArray], { type: getMimetype(name) });
21490             } catch(e) {
21491               Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
21492             }
21493           }
21494           if (!b) {
21495             var bb = new Browser.BlobBuilder();
21496             bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
21497             b = bb.getBlob();
21498           }
21499           var url = Browser.URLObject.createObjectURL(b);
21500           assert(typeof url == 'string', 'createObjectURL must return a url as a string');
21501           var img = new Image();
21502           img.onload = function() {
21503             assert(img.complete, 'Image ' + name + ' could not be decoded');
21504             var canvas = document.createElement('canvas');
21505             canvas.width = img.width;
21506             canvas.height = img.height;
21507             var ctx = canvas.getContext('2d');
21508             ctx.drawImage(img, 0, 0);
21509             Module["preloadedImages"][name] = canvas;
21510             Browser.URLObject.revokeObjectURL(url);
21511             if (onload) onload(byteArray);
21512           };
21513           img.onerror = function(event) {
21514             console.log('Image ' + url + ' could not be decoded');
21515             if (onerror) onerror();
21516           };
21517           img.src = url;
21518         };
21519         Module['preloadPlugins'].push(imagePlugin);
21520
21521         var audioPlugin = {};
21522         audioPlugin['canHandle'] = function(name) {
21523           return name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
21524         };
21525         audioPlugin['handle'] = function(byteArray, name, onload, onerror) {
21526           var done = false;
21527           function finish(audio) {
21528             if (done) return;
21529             done = true;
21530             Module["preloadedAudios"][name] = audio;
21531             if (onload) onload(byteArray);
21532           }
21533           function fail() {
21534             if (done) return;
21535             done = true;
21536             Module["preloadedAudios"][name] = new Audio(); // empty shim
21537             if (onerror) onerror();
21538           }
21539           if (Browser.hasBlobConstructor) {
21540             try {
21541               var b = new Blob([byteArray], { type: getMimetype(name) });
21542             } catch(e) {
21543               return fail();
21544             }
21545             var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
21546             assert(typeof url == 'string', 'createObjectURL must return a url as a string');
21547             var audio = new Audio();
21548             audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
21549             audio.onerror = function(event) {
21550               if (done) return;
21551               console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
21552               function encode64(data) {
21553                 var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
21554                 var PAD = '=';
21555                 var ret = '';
21556                 var leftchar = 0;
21557                 var leftbits = 0;
21558                 for (var i = 0; i < data.length; i++) {
21559                   leftchar = (leftchar << 8) | data[i];
21560                   leftbits += 8;
21561                   while (leftbits >= 6) {
21562                     var curr = (leftchar >> (leftbits-6)) & 0x3f;
21563                     leftbits -= 6;
21564                     ret += BASE[curr];
21565                   }
21566                 }
21567                 if (leftbits == 2) {
21568                   ret += BASE[(leftchar&3) << 4];
21569                   ret += PAD + PAD;
21570                 } else if (leftbits == 4) {
21571                   ret += BASE[(leftchar&0xf) << 2];
21572                   ret += PAD;
21573                 }
21574                 return ret;
21575               }
21576               audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
21577               finish(audio); // we don't wait for confirmation this worked - but it's worth trying
21578             };
21579             audio.src = url;
21580             // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
21581             setTimeout(function() {
21582               finish(audio); // try to use it even though it is not necessarily ready to play
21583             }, 10000);
21584           } else {
21585             return fail();
21586           }
21587         };
21588         Module['preloadPlugins'].push(audioPlugin);
21589       },createContext:function (canvas, useWebGL, setInModule) {
21590         try {
21591           var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d');
21592           if (!ctx) throw ':(';
21593         } catch (e) {
21594           Module.print('Could not create canvas - ' + e);
21595           return null;
21596         }
21597         if (useWebGL) {
21598           // Set the background of the WebGL canvas to black
21599           canvas.style.backgroundColor = "black";
21600
21601           // Warn on context loss
21602           canvas.addEventListener('webglcontextlost', function(event) {
21603             alert('WebGL context lost. You will need to reload the page.');
21604           }, false);
21605         }
21606         if (setInModule) {
21607           Module.ctx = ctx;
21608           Module.useWebGL = useWebGL;
21609           Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
21610         }
21611         return ctx;
21612       },requestFullScreen:function () {
21613         var canvas = Module['canvas'];
21614         function fullScreenChange() {
21615           var isFullScreen = false;
21616           if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
21617                document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
21618                document['fullScreenElement'] || document['fullscreenElement']) === canvas) {
21619             canvas.requestPointerLock = canvas['requestPointerLock'] ||
21620                                         canvas['mozRequestPointerLock'] ||
21621                                         canvas['webkitRequestPointerLock'];
21622             canvas.requestPointerLock();
21623             isFullScreen = true;
21624           }
21625           if (Module['onFullScreen']) Module['onFullScreen'](isFullScreen);
21626         }
21627
21628         document.addEventListener('fullscreenchange', fullScreenChange, false);
21629         document.addEventListener('mozfullscreenchange', fullScreenChange, false);
21630         document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
21631
21632         function pointerLockChange() {
21633           Browser.pointerLock = document['pointerLockElement'] === canvas ||
21634                                 document['mozPointerLockElement'] === canvas ||
21635                                 document['webkitPointerLockElement'] === canvas;
21636         }
21637
21638         document.addEventListener('pointerlockchange', pointerLockChange, false);
21639         document.addEventListener('mozpointerlockchange', pointerLockChange, false);
21640         document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
21641
21642         canvas.requestFullScreen = canvas['requestFullScreen'] ||
21643                                    canvas['mozRequestFullScreen'] ||
21644                                    (canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
21645         canvas.requestFullScreen();
21646       },requestAnimationFrame:function (func) {
21647         if (!window.requestAnimationFrame) {
21648           window.requestAnimationFrame = window['requestAnimationFrame'] ||
21649                                          window['mozRequestAnimationFrame'] ||
21650                                          window['webkitRequestAnimationFrame'] ||
21651                                          window['msRequestAnimationFrame'] ||
21652                                          window['oRequestAnimationFrame'] ||
21653                                          window['setTimeout'];
21654         }
21655         window.requestAnimationFrame(func);
21656       },getMovementX:function (event) {
21657         return event['movementX'] ||
21658                event['mozMovementX'] ||
21659                event['webkitMovementX'] ||
21660                0;
21661       },getMovementY:function (event) {
21662         return event['movementY'] ||
21663                event['mozMovementY'] ||
21664                event['webkitMovementY'] ||
21665                0;
21666       },xhrLoad:function (url, onload, onerror) {
21667         var xhr = new XMLHttpRequest();
21668         xhr.open('GET', url, true);
21669         xhr.responseType = 'arraybuffer';
21670         xhr.onload = function() {
21671           if (xhr.status == 200) {
21672             onload(xhr.response);
21673           } else {
21674             onerror();
21675           }
21676         };
21677         xhr.onerror = onerror;
21678         xhr.send(null);
21679       },asyncLoad:function (url, onload, onerror) {
21680         Browser.xhrLoad(url, function(arrayBuffer) {
21681           assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
21682           onload(new Uint8Array(arrayBuffer));
21683           removeRunDependency('al ' + url);
21684         }, function(event) {
21685           if (onerror) {
21686             onerror();
21687           } else {
21688             throw 'Loading data file "' + url + '" failed.';
21689           }
21690         });
21691         addRunDependency('al ' + url);
21692       },resizeListeners:[],updateResizeListeners:function () {
21693         var canvas = Module['canvas'];
21694         Browser.resizeListeners.forEach(function(listener) {
21695           listener(canvas.width, canvas.height);
21696         });
21697       },setCanvasSize:function (width, height, noUpdates) {
21698         var canvas = Module['canvas'];
21699         canvas.width = width;
21700         canvas.height = height;
21701         if (!noUpdates) Browser.updateResizeListeners();
21702       }};
21703 __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;
21704 ___setErrNo(0);
21705 _fputc.ret = allocate([0], "i8", ALLOC_STATIC);
21706 Module["requestFullScreen"] = function() { Browser.requestFullScreen() };
21707   Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) };
21708   Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() };
21709   Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() };
21710
21711
21712 // === Auto-generated postamble setup entry stuff ===
21713
21714 Module.callMain = function callMain(args) {
21715   var argc = args.length+1;
21716   function pad() {
21717     for (var i = 0; i < 4-1; i++) {
21718       argv.push(0);
21719     }
21720   }
21721   var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ];
21722   pad();
21723   for (var i = 0; i < argc-1; i = i + 1) {
21724     argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC));
21725     pad();
21726   }
21727   argv.push(0);
21728   argv = allocate(argv, 'i32', ALLOC_STATIC);
21729
21730   return _main(argc, argv, 0);
21731 }
21732
21733
21734
21735
21736
21737
21738
21739
21740
21741
21742
21743
21744
21745
21746
21747
21748
21749
21750
21751
21752
21753
21754
21755
21756
21757
21758
21759
21760
21761
21762
21763 var _asm_instr;
21764
21765
21766
21767 var _prog_print_statement_t;
21768
21769
21770 var _stdout;
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
21824
21825
21826
21827
21828
21829
21830
21831
21832
21833
21834
21835
21836
21837
21838
21839
21840
21841
21842
21843
21844
21845
21846
21847
21848
21849 STRING_TABLE.__str=allocate([101,120,101,99,46,99,0] /* exec.c\00 */, "i8", ALLOC_STATIC);
21850 STRING_TABLE.__str1=allocate([114,98,0] /* rb\00 */, "i8", ALLOC_STATIC);
21851 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);
21852 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);
21853 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);
21854 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);
21855 STRING_TABLE.__str6=allocate([115,101,101,107,32,102,97,105,108,101,100,0] /* seek failed\00 */, "i8", ALLOC_STATIC);
21856 STRING_TABLE.__str7=allocate([114,101,97,100,32,102,97,105,108,101,100,0] /* read failed\00 */, "i8", ALLOC_STATIC);
21857 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);
21858 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);
21859 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);
21860 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);
21861 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);
21862 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);
21863 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);
21864 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);
21865 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);
21866 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);
21867 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);
21868 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);
21869 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);
21870 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);
21871 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);
21872 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);
21873 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);
21874 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);
21875 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);
21876 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);
21877 STRING_TABLE.__str28=allocate([32,60,62,32,37,45,49,50,115,0] /*  __ %-12s\00 */, "i8", ALLOC_STATIC);
21878 _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);
21879 STRING_TABLE.__str29=allocate([37,100,10,0] /* %d\0A\00 */, "i8", ALLOC_STATIC);
21880 STRING_TABLE.__str30=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC);
21881 STRING_TABLE.__str31=allocate([37,105,10,0] /* %i\0A\00 */, "i8", ALLOC_STATIC);
21882 _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);
21883 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);
21884 STRING_TABLE.__str33=allocate([40,110,111,110,101,41,0] /* (none)\00 */, "i8", ALLOC_STATIC);
21885 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);
21886 STRING_TABLE.__str34=allocate([60,110,117,108,108,62,44,0] /* _null_,\00 */, "i8", ALLOC_STATIC);
21887 STRING_TABLE.__str35=allocate([36,0] /* $\00 */, "i8", ALLOC_STATIC);
21888 STRING_TABLE.__str36=allocate([37,115,32,0] /* %s \00 */, "i8", ALLOC_STATIC);
21889 STRING_TABLE.__str37=allocate([91,64,37,117,93,32,0] /* [@%u] \00 */, "i8", ALLOC_STATIC);
21890 STRING_TABLE.__str38=allocate([40,37,105,41,44,0] /* (%i),\00 */, "i8", ALLOC_STATIC);
21891 STRING_TABLE.__str39=allocate([39,37,103,32,37,103,32,37,103,39,44,0] /* '%g %g %g',\00 */, "i8", ALLOC_STATIC);
21892 STRING_TABLE.__str40=allocate([44,0] /* ,\00 */, "i8", ALLOC_STATIC);
21893 STRING_TABLE.__str41=allocate([37,103,44,0] /* %g,\00 */, "i8", ALLOC_STATIC);
21894 STRING_TABLE.__str42=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC);
21895 STRING_TABLE.__str43=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC);
21896 STRING_TABLE.__str44=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC);
21897 STRING_TABLE.__str45=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC);
21898 STRING_TABLE.__str46=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC);
21899 STRING_TABLE.__str47=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC);
21900 STRING_TABLE.__str48=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC);
21901 STRING_TABLE.__str49=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC);
21902 STRING_TABLE.__str50=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC);
21903 STRING_TABLE.__str51=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC);
21904 STRING_TABLE.__str52=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC);
21905 STRING_TABLE.__str53=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC);
21906 STRING_TABLE.__str54=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC);
21907 STRING_TABLE.__str55=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC);
21908 STRING_TABLE.__str56=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC);
21909 STRING_TABLE.__str57=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC);
21910 STRING_TABLE.__str58=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC);
21911 STRING_TABLE.__str59=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC);
21912 STRING_TABLE.__str60=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC);
21913 STRING_TABLE.__str61=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC);
21914 STRING_TABLE.__str62=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC);
21915 STRING_TABLE.__str63=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC);
21916 STRING_TABLE.__str64=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC);
21917 STRING_TABLE.__str65=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC);
21918 STRING_TABLE.__str66=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC);
21919 STRING_TABLE.__str67=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC);
21920 STRING_TABLE.__str68=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC);
21921 STRING_TABLE.__str69=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC);
21922 STRING_TABLE.__str70=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC);
21923 STRING_TABLE.__str71=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC);
21924 STRING_TABLE.__str72=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC);
21925 STRING_TABLE.__str73=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC);
21926 STRING_TABLE.__str74=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC);
21927 STRING_TABLE.__str75=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC);
21928 STRING_TABLE.__str76=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC);
21929 STRING_TABLE.__str77=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC);
21930 STRING_TABLE.__str78=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC);
21931 STRING_TABLE.__str79=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC);
21932 STRING_TABLE.__str80=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC);
21933 STRING_TABLE.__str81=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC);
21934 STRING_TABLE.__str82=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC);
21935 STRING_TABLE.__str83=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC);
21936 STRING_TABLE.__str84=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC);
21937 STRING_TABLE.__str85=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC);
21938 STRING_TABLE.__str86=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC);
21939 STRING_TABLE.__str87=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC);
21940 STRING_TABLE.__str88=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC);
21941 STRING_TABLE.__str89=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC);
21942 STRING_TABLE.__str90=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC);
21943 STRING_TABLE.__str91=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC);
21944 STRING_TABLE.__str92=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC);
21945 STRING_TABLE.__str93=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC);
21946 STRING_TABLE.__str94=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC);
21947 STRING_TABLE.__str95=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC);
21948 STRING_TABLE.__str96=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC);
21949 STRING_TABLE.__str97=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC);
21950 STRING_TABLE.__str98=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC);
21951 STRING_TABLE.__str99=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC);
21952 STRING_TABLE.__str100=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC);
21953 STRING_TABLE.__str101=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC);
21954 STRING_TABLE.__str102=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC);
21955 STRING_TABLE.__str103=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC);
21956 STRING_TABLE.__str104=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC);
21957 STRING_TABLE.__str105=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC);
21958 STRING_TABLE.__str106=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC);
21959 STRING_TABLE.__str107=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC);
21960 STRING_TABLE.__str108=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC);
21961 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);
21962 STRING_TABLE.__str110=allocate([58,32,37,115,10,0] /* : %s\0A\00 */, "i8", ALLOC_STATIC);
21963 HEAP32[((_asm_instr)>>2)]=((STRING_TABLE.__str42)|0);
21964 HEAP32[(((_asm_instr)+(12))>>2)]=((STRING_TABLE.__str43)|0);
21965 HEAP32[(((_asm_instr)+(24))>>2)]=((STRING_TABLE.__str44)|0);
21966 HEAP32[(((_asm_instr)+(36))>>2)]=((STRING_TABLE.__str45)|0);
21967 HEAP32[(((_asm_instr)+(48))>>2)]=((STRING_TABLE.__str46)|0);
21968 HEAP32[(((_asm_instr)+(60))>>2)]=((STRING_TABLE.__str47)|0);
21969 HEAP32[(((_asm_instr)+(72))>>2)]=((STRING_TABLE.__str48)|0);
21970 HEAP32[(((_asm_instr)+(84))>>2)]=((STRING_TABLE.__str49)|0);
21971 HEAP32[(((_asm_instr)+(96))>>2)]=((STRING_TABLE.__str50)|0);
21972 HEAP32[(((_asm_instr)+(108))>>2)]=((STRING_TABLE.__str51)|0);
21973 HEAP32[(((_asm_instr)+(120))>>2)]=((STRING_TABLE.__str52)|0);
21974 HEAP32[(((_asm_instr)+(132))>>2)]=((STRING_TABLE.__str53)|0);
21975 HEAP32[(((_asm_instr)+(144))>>2)]=((STRING_TABLE.__str54)|0);
21976 HEAP32[(((_asm_instr)+(156))>>2)]=((STRING_TABLE.__str55)|0);
21977 HEAP32[(((_asm_instr)+(168))>>2)]=((STRING_TABLE.__str56)|0);
21978 HEAP32[(((_asm_instr)+(180))>>2)]=((STRING_TABLE.__str57)|0);
21979 HEAP32[(((_asm_instr)+(192))>>2)]=((STRING_TABLE.__str58)|0);
21980 HEAP32[(((_asm_instr)+(204))>>2)]=((STRING_TABLE.__str59)|0);
21981 HEAP32[(((_asm_instr)+(216))>>2)]=((STRING_TABLE.__str60)|0);
21982 HEAP32[(((_asm_instr)+(228))>>2)]=((STRING_TABLE.__str61)|0);
21983 HEAP32[(((_asm_instr)+(240))>>2)]=((STRING_TABLE.__str62)|0);
21984 HEAP32[(((_asm_instr)+(252))>>2)]=((STRING_TABLE.__str63)|0);
21985 HEAP32[(((_asm_instr)+(264))>>2)]=((STRING_TABLE.__str64)|0);
21986 HEAP32[(((_asm_instr)+(276))>>2)]=((STRING_TABLE.__str65)|0);
21987 HEAP32[(((_asm_instr)+(288))>>2)]=((STRING_TABLE.__str66)|0);
21988 HEAP32[(((_asm_instr)+(300))>>2)]=((STRING_TABLE.__str67)|0);
21989 HEAP32[(((_asm_instr)+(312))>>2)]=((STRING_TABLE.__str68)|0);
21990 HEAP32[(((_asm_instr)+(324))>>2)]=((STRING_TABLE.__str69)|0);
21991 HEAP32[(((_asm_instr)+(336))>>2)]=((STRING_TABLE.__str70)|0);
21992 HEAP32[(((_asm_instr)+(348))>>2)]=((STRING_TABLE.__str71)|0);
21993 HEAP32[(((_asm_instr)+(360))>>2)]=((STRING_TABLE.__str72)|0);
21994 HEAP32[(((_asm_instr)+(372))>>2)]=((STRING_TABLE.__str73)|0);
21995 HEAP32[(((_asm_instr)+(384))>>2)]=((STRING_TABLE.__str74)|0);
21996 HEAP32[(((_asm_instr)+(396))>>2)]=((STRING_TABLE.__str75)|0);
21997 HEAP32[(((_asm_instr)+(408))>>2)]=((STRING_TABLE.__str76)|0);
21998 HEAP32[(((_asm_instr)+(420))>>2)]=((STRING_TABLE.__str77)|0);
21999 HEAP32[(((_asm_instr)+(432))>>2)]=((STRING_TABLE.__str78)|0);
22000 HEAP32[(((_asm_instr)+(444))>>2)]=((STRING_TABLE.__str79)|0);
22001 HEAP32[(((_asm_instr)+(456))>>2)]=((STRING_TABLE.__str80)|0);
22002 HEAP32[(((_asm_instr)+(468))>>2)]=((STRING_TABLE.__str81)|0);
22003 HEAP32[(((_asm_instr)+(480))>>2)]=((STRING_TABLE.__str82)|0);
22004 HEAP32[(((_asm_instr)+(492))>>2)]=((STRING_TABLE.__str83)|0);
22005 HEAP32[(((_asm_instr)+(504))>>2)]=((STRING_TABLE.__str84)|0);
22006 HEAP32[(((_asm_instr)+(516))>>2)]=((STRING_TABLE.__str85)|0);
22007 HEAP32[(((_asm_instr)+(528))>>2)]=((STRING_TABLE.__str86)|0);
22008 HEAP32[(((_asm_instr)+(540))>>2)]=((STRING_TABLE.__str87)|0);
22009 HEAP32[(((_asm_instr)+(552))>>2)]=((STRING_TABLE.__str88)|0);
22010 HEAP32[(((_asm_instr)+(564))>>2)]=((STRING_TABLE.__str89)|0);
22011 HEAP32[(((_asm_instr)+(576))>>2)]=((STRING_TABLE.__str90)|0);
22012 HEAP32[(((_asm_instr)+(588))>>2)]=((STRING_TABLE.__str91)|0);
22013 HEAP32[(((_asm_instr)+(600))>>2)]=((STRING_TABLE.__str92)|0);
22014 HEAP32[(((_asm_instr)+(612))>>2)]=((STRING_TABLE.__str93)|0);
22015 HEAP32[(((_asm_instr)+(624))>>2)]=((STRING_TABLE.__str94)|0);
22016 HEAP32[(((_asm_instr)+(636))>>2)]=((STRING_TABLE.__str95)|0);
22017 HEAP32[(((_asm_instr)+(648))>>2)]=((STRING_TABLE.__str96)|0);
22018 HEAP32[(((_asm_instr)+(660))>>2)]=((STRING_TABLE.__str97)|0);
22019 HEAP32[(((_asm_instr)+(672))>>2)]=((STRING_TABLE.__str98)|0);
22020 HEAP32[(((_asm_instr)+(684))>>2)]=((STRING_TABLE.__str99)|0);
22021 HEAP32[(((_asm_instr)+(696))>>2)]=((STRING_TABLE.__str100)|0);
22022 HEAP32[(((_asm_instr)+(708))>>2)]=((STRING_TABLE.__str101)|0);
22023 HEAP32[(((_asm_instr)+(720))>>2)]=((STRING_TABLE.__str102)|0);
22024 HEAP32[(((_asm_instr)+(732))>>2)]=((STRING_TABLE.__str103)|0);
22025 HEAP32[(((_asm_instr)+(744))>>2)]=((STRING_TABLE.__str104)|0);
22026 HEAP32[(((_asm_instr)+(756))>>2)]=((STRING_TABLE.__str105)|0);
22027 HEAP32[(((_asm_instr)+(768))>>2)]=((STRING_TABLE.__str106)|0);
22028 HEAP32[(((_asm_instr)+(780))>>2)]=((STRING_TABLE.__str107)|0);
22029 HEAP32[(((_asm_instr)+(792))>>2)]=((STRING_TABLE.__str108)|0);
22030 FUNCTION_TABLE = [0,0]; Module["FUNCTION_TABLE"] = FUNCTION_TABLE;
22031
22032
22033 function run(args) {
22034   args = args || Module['arguments'];
22035
22036   if (runDependencies > 0) {
22037     Module.printErr('run() called, but dependencies remain, so not running');
22038     return 0;
22039   }
22040
22041   if (Module['preRun']) {
22042     if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
22043     var toRun = Module['preRun'];
22044     Module['preRun'] = [];
22045     for (var i = toRun.length-1; i >= 0; i--) {
22046       toRun[i]();
22047     }
22048     if (runDependencies > 0) {
22049       // a preRun added a dependency, run will be called later
22050       return 0;
22051     }
22052   }
22053
22054   function doRun() {
22055     var ret = 0;
22056     calledRun = true;
22057     if (Module['_main']) {
22058       preMain();
22059       ret = Module.callMain(args);
22060       if (!Module['noExitRuntime']) {
22061         exitRuntime();
22062       }
22063     }
22064     if (Module['postRun']) {
22065       if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
22066       while (Module['postRun'].length > 0) {
22067         Module['postRun'].pop()();
22068       }
22069     }
22070     return ret;
22071   }
22072
22073   if (Module['setStatus']) {
22074     Module['setStatus']('Running...');
22075     setTimeout(function() {
22076       setTimeout(function() {
22077         Module['setStatus']('');
22078       }, 1);
22079       doRun();
22080     }, 1);
22081     return 0;
22082   } else {
22083     return doRun();
22084   }
22085 }
22086 Module['run'] = run;
22087
22088 // {{PRE_RUN_ADDITIONS}}
22089
22090 if (Module['preInit']) {
22091   if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
22092   while (Module['preInit'].length > 0) {
22093     Module['preInit'].pop()();
22094   }
22095 }
22096
22097 initRuntime();
22098
22099 var shouldRunNow = true;
22100 if (Module['noInitialRun']) {
22101   shouldRunNow = false;
22102 }
22103
22104 if (shouldRunNow) {
22105   var ret = run();
22106 }
22107
22108 // {{POST_RUN_ADDITIONS}}
22109
22110
22111
22112
22113
22114
22115   // {{MODULE_ADDITIONS}}
22116
22117
22118 // 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"]
22119