From: Dale Weiler Date: Mon, 12 Nov 2012 13:57:34 +0000 (+0000) Subject: Added compiler and virtual machine JS X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=44cc17a0e16b9e3ed1e940804228f8d6a559d611;p=xonotic%2Fgmqcc.git Added compiler and virtual machine JS --- diff --git a/javascripts/compiler.js b/javascripts/compiler.js index bd7dbaa..663629c 100644 --- a/javascripts/compiler.js +++ b/javascripts/compiler.js @@ -1,25 +1,56057 @@ -// compiler bootstraps down to the emcscripten compiled compiler -// and the execution +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. +// TODO: " u s e s t r i c t "; -var std = "gmqcc"; -var example = "1"; -function update() { - var select = document.getElementById("std"); - var change = select.options[select.selectedIndex].value; - if (change != std) { - std = change; +try { + this['Module'] = Module; +} catch(e) { + this['Module'] = Module = {}; +} + +// The environment setup code below is customized to use Module. +// *** Environment setup code *** +var ENVIRONMENT_IS_NODE = typeof process === 'object'; +var ENVIRONMENT_IS_WEB = typeof window === 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (ENVIRONMENT_IS_NODE) { + // Expose functionality in the same simple way that the shells work + // Note that we pollute the global namespace here, otherwise we break in node + Module['print'] = function(x) { + process['stdout'].write(x + '\n'); + }; + Module['printErr'] = function(x) { + process['stderr'].write(x + '\n'); + }; + + var nodeFS = require('fs'); + var nodePath = require('path'); + + Module['read'] = function(filename) { + filename = nodePath['normalize'](filename); + var ret = nodeFS['readFileSync'](filename).toString(); + // The path is absolute if the normalized version is the same as the resolved. + if (!ret && filename != nodePath['resolve'](filename)) { + filename = path.join(__dirname, '..', 'src', filename); + ret = nodeFS['readFileSync'](filename).toString(); + } + return ret; + }; + + Module['load'] = function(f) { + globalEval(read(f)); + }; + + if (!Module['arguments']) { + Module['arguments'] = process['argv'].slice(2); + } +} + +if (ENVIRONMENT_IS_SHELL) { + Module['print'] = print; + if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm + + // Polyfill over SpiderMonkey/V8 differences + if (typeof read != 'undefined') { + Module['read'] = read; + } else { + Module['read'] = function(f) { snarf(f) }; + } + + if (!Module['arguments']) { + if (typeof scriptArgs != 'undefined') { + Module['arguments'] = scriptArgs; + } else if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + } +} + +if (ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER) { + if (!Module['print']) { + Module['print'] = function(x) { + console.log(x); + }; + } + + if (!Module['printErr']) { + Module['printErr'] = function(x) { + console.log(x); + }; + } +} + +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + Module['read'] = function(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (!Module['arguments']) { + if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + } +} + +if (ENVIRONMENT_IS_WORKER) { + // We can do very little here... + var TRY_USE_DUMP = false; + if (!Module['print']) { + Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) { + dump(x); + }) : (function(x) { + // self.postMessage(x); // enable this if you want stdout to be sent as messages + })); + } + + Module['load'] = importScripts; +} + +if (!ENVIRONMENT_IS_WORKER && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL) { + // Unreachable because SHELL is dependant on the others + throw 'Unknown runtime environment. Where are we?'; +} + +function globalEval(x) { + eval.call(null, x); +} +if (!Module['load'] == 'undefined' && Module['read']) { + Module['load'] = function(f) { + globalEval(Module['read'](f)); + }; +} +if (!Module['print']) { + Module['print'] = function(){}; +} +if (!Module['printErr']) { + Module['printErr'] = Module['print']; +} +if (!Module['arguments']) { + Module['arguments'] = []; +} +// *** Environment setup code *** + +// Closure helpers +Module.print = Module['print']; +Module.printErr = Module['printErr']; + +// Callbacks +if (!Module['preRun']) Module['preRun'] = []; +if (!Module['postRun']) Module['postRun'] = []; + + +// === Auto-generated preamble library stuff === + +//======================================== +// Runtime code shared with compiler +//======================================== + +var Runtime = { + stackSave: function () { + return STACKTOP; + }, + stackRestore: function (stackTop) { + STACKTOP = stackTop; + }, + forceAlign: function (target, quantum) { + quantum = quantum || 4; + if (quantum == 1) return target; + if (isNumber(target) && isNumber(quantum)) { + return Math.ceil(target/quantum)*quantum; + } else if (isNumber(quantum) && isPowerOfTwo(quantum)) { + var logg = log2(quantum); + return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')'; + } + return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum; + }, + isNumberType: function (type) { + return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES; + }, + isPointerType: function isPointerType(type) { + return type[type.length-1] == '*'; +}, + isStructType: function isStructType(type) { + if (isPointerType(type)) return false; + if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs + if (/?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types + // See comment in isStructPointerType() + return type[0] == '%'; +}, + INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0}, + FLOAT_TYPES: {"float":0,"double":0}, + bitshift64: function (low, high, op, bits) { + var ander = Math.pow(2, bits)-1; + if (bits < 32) { + switch (op) { + case 'shl': + return [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))]; + case 'ashr': + return [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0]; + case 'lshr': + return [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits]; + } + } else if (bits == 32) { + switch (op) { + case 'shl': + return [0, low]; + case 'ashr': + return [high, (high|0) < 0 ? ander : 0]; + case 'lshr': + return [high, 0]; + } + } else { // bits > 32 + switch (op) { + case 'shl': + return [0, low << (bits - 32)]; + case 'ashr': + return [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0]; + case 'lshr': + return [high >>> (bits - 32) , 0]; + } + } + abort('unknown bitshift64 op: ' + [value, op, bits]); + }, + or64: function (x, y) { + var l = (x | 0) | (y | 0); + var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + and64: function (x, y) { + var l = (x | 0) & (y | 0); + var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + xor64: function (x, y) { + var l = (x | 0) ^ (y | 0); + var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + getNativeTypeSize: function (type, quantumSize) { + if (Runtime.QUANTUM_SIZE == 1) return 1; + var size = { + '%i1': 1, + '%i8': 1, + '%i16': 2, + '%i32': 4, + '%i64': 8, + "%float": 4, + "%double": 8 + }['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc + if (!size) { + if (type.charAt(type.length-1) == '*') { + size = Runtime.QUANTUM_SIZE; // A pointer + } else if (type[0] == 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 == 0); + size = bits/8; + } + } + return size; + }, + getNativeFieldSize: function (type) { + return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE); + }, + dedup: function dedup(items, ident) { + var seen = {}; + if (ident) { + return items.filter(function(item) { + if (seen[item[ident]]) return false; + seen[item[ident]] = true; + return true; + }); + } else { + return items.filter(function(item) { + if (seen[item]) return false; + seen[item] = true; + return true; + }); + } +}, + set: function set() { + var args = typeof arguments[0] === 'object' ? arguments[0] : arguments; + var ret = {}; + for (var i = 0; i < args.length; i++) { + ret[args[i]] = 0; + } + return ret; +}, + calculateStructAlignment: function calculateStructAlignment(type) { + type.flatSize = 0; + type.alignSize = 0; + var diffs = []; + var prev = -1; + type.flatIndexes = type.fields.map(function(field) { + var size, alignSize; + if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) { + size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s. + alignSize = size; + } else if (Runtime.isStructType(field)) { + size = Types.types[field].flatSize; + alignSize = Types.types[field].alignSize; + } else { + throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]); + } + alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE); + type.alignSize = Math.max(type.alignSize, alignSize); + var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory + type.flatSize = curr + size; + if (prev >= 0) { + diffs.push(curr-prev); + } + prev = curr; + return curr; + }); + type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize); + if (diffs.length == 0) { + type.flatFactor = type.flatSize; + } else if (Runtime.dedup(diffs).length == 1) { + type.flatFactor = diffs[0]; + } + type.needsFlattening = (type.flatFactor != 1); + return type.flatIndexes; + }, + generateStructInfo: function (struct, typeName, offset) { + var type, alignment; + if (typeName) { + offset = offset || 0; + type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName]; + if (!type) return null; + if (type.fields.length != struct.length) { + printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo'); + return null; + } + alignment = type.flatIndexes; + } else { + var type = { fields: struct.map(function(item) { return item[0] }) }; + alignment = Runtime.calculateStructAlignment(type); + } + var ret = { + __size__: type.flatSize + }; + if (typeName) { + struct.forEach(function(item, i) { + if (typeof item === 'string') { + ret[item] = alignment[i] + offset; + } else { + // embedded struct + var key; + for (var k in item) key = k; + ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]); + } + }); + } else { + struct.forEach(function(item, i) { + ret[item[1]] = alignment[i]; + }); + } + return ret; + }, + addFunction: function (func) { + var ret = FUNCTION_TABLE.length; + FUNCTION_TABLE.push(func); + FUNCTION_TABLE.push(0); + return ret; + }, + warnOnce: function (text) { + if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {}; + if (!Runtime.warnOnce.shown[text]) { + Runtime.warnOnce.shown[text] = 1; + Module.printErr(text); + } + }, + funcWrappers: {}, + getFuncWrapper: function (func) { + if (!Runtime.funcWrappers[func]) { + Runtime.funcWrappers[func] = function() { + FUNCTION_TABLE[func].apply(null, arguments); + }; + } + return Runtime.funcWrappers[func]; + }, + UTF8Processor: function () { + var buffer = []; + var needed = 0; + this.processCChar = function (code) { + code = code & 0xff; + if (needed) { + buffer.push(code); + needed--; + } + if (buffer.length == 0) { + if (code < 128) return String.fromCharCode(code); + buffer.push(code); + if (code > 191 && code < 224) { + needed = 1; + } else { + needed = 2; + } + return ''; + } + if (needed > 0) return ''; + var c1 = buffer[0]; + var c2 = buffer[1]; + var c3 = buffer[2]; + var ret; + if (c1 > 191 && c1 < 224) { + ret = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63)); + } else { + ret = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); + } + buffer.length = 0; + return ret; + } + this.processJSString = function(string) { + string = unescape(encodeURIComponent(string)); + var ret = []; + for (var i = 0; i < string.length; i++) { + ret.push(string.charCodeAt(i)); + } + return ret; + } + }, + 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; }, + staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP += size;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; }, + alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; }, + makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; }, + QUANTUM_SIZE: 4, + __dummy__: 0 +} + + + +var CorrectionsMonitor = { + MAX_ALLOWED: 0, // XXX + corrections: 0, + sigs: {}, + + note: function(type, succeed, sig) { + if (!succeed) { + this.corrections++; + if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!'); + } + }, + + print: function() { + } +}; + + + + + +//======================================== +// Runtime essentials +//======================================== + +var __THREW__ = false; // Used in checking for thrown exceptions. + +var ABORT = false; + +var undef = 0; +// tempInt is used for 32-bit signed values or smaller. tempBigInt is used +// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt +var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD; +var tempI64, tempI64b; + +function abort(text) { + Module.print(text + ':\n' + (new Error).stack); + ABORT = true; + throw "Assertion: " + text; +} + +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +var globalScope = this; + +// C calling interface. A convenient way to call C functions (in C files, or +// defined with extern "C"). +// +// Note: LLVM optimizations can inline and remove functions, after which you will not be +// able to call them. Adding +// +// __attribute__((used)) +// +// to the function definition will prevent that. +// +// Note: Closure optimizations will minify function names, making +// functions no longer callable. If you run closure (on by default +// in -O2 and above), you should export the functions you will call +// by calling emcc with something like +// +// -s EXPORTED_FUNCTIONS='["_func1","_func2"]' +// +// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C") +// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and +// 'array' for JavaScript arrays and typed arrays). +// @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, +// except that 'array' is not possible (there is no way for us to know the length of the array) +// @param args An array of the arguments to the function, as native JS values (as in returnType) +// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack). +// @return The return value, as a native JS value (as in returnType) +function ccall(ident, returnType, argTypes, args) { + var stack = 0; + function toC(value, type) { + if (type == 'string') { + if (value === null || value === undefined || value === 0) return 0; // null string + if (!stack) stack = Runtime.stackSave(); + var ret = Runtime.stackAlloc(value.length+1); + writeStringToMemory(value, ret); + return ret; + } else if (type == 'array') { + if (!stack) stack = Runtime.stackSave(); + var ret = Runtime.stackAlloc(value.length); + writeArrayToMemory(value, ret); + return ret; + } + return value; + } + function fromC(value, type) { + if (type == 'string') { + return Pointer_stringify(value); + } + assert(type != 'array'); + return value; + } + try { + var func = eval('_' + ident); + } catch(e) { + try { + func = globalScope['Module']['_' + ident]; // closure exported function + } catch(e) {} + } + assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)'); + var i = 0; + var cArgs = args ? args.map(function(arg) { + return toC(arg, argTypes[i++]); + }) : []; + var ret = fromC(func.apply(null, cArgs), returnType); + if (stack) Runtime.stackRestore(stack); + return ret; +} +Module["ccall"] = ccall; + +// Returns a native JS wrapper for a C function. This is similar to ccall, but +// returns a function you can call repeatedly in a normal way. For example: +// +// var my_function = cwrap('my_c_function', 'number', ['number', 'number']); +// alert(my_function(5, 22)); +// alert(my_function(99, 12)); +// +function cwrap(ident, returnType, argTypes) { + // TODO: optimize this, eval the whole function once instead of going through ccall each time + return function() { + return ccall(ident, returnType, argTypes, Array.prototype.slice.call(arguments)); + } +} +Module["cwrap"] = cwrap; + +// Sets a value in memory in a dynamic way at run-time. Uses the +// type data. This is the same as makeSetValue, except that +// makeSetValue is done at compile-time and generates the needed +// code then, whereas this function picks the right code at +// run-time. +// Note that setValue and getValue only do *aligned* writes and reads! +// Note that ccall uses JS types as for defining types, while setValue and +// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[(ptr)]=value; break; + case 'i8': HEAP8[(ptr)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,Math.min(Math.floor((value)/4294967296), 4294967295)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': (tempDoubleF64[0]=value,HEAP32[((ptr)>>2)]=tempDoubleI32[0],HEAP32[(((ptr)+(4))>>2)]=tempDoubleI32[1]); break; + default: abort('invalid type for setValue: ' + type); + } +} +Module['setValue'] = setValue; + +// Parallel to setValue. +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[(ptr)]; + case 'i8': return HEAP8[(ptr)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return (tempDoubleI32[0]=HEAP32[((ptr)>>2)],tempDoubleI32[1]=HEAP32[(((ptr)+(4))>>2)],tempDoubleF64[0]); + default: abort('invalid type for setValue: ' + type); + } + return null; +} +Module['getValue'] = getValue; + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_STATIC = 2; // Cannot be freed +Module['ALLOC_NORMAL'] = ALLOC_NORMAL; +Module['ALLOC_STACK'] = ALLOC_STACK; +Module['ALLOC_STATIC'] = ALLOC_STATIC; + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +function allocate(slab, types, allocator) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length)); + + if (zeroinit) { + _memset(ret, 0, size); + return ret; + } + + var i = 0, type; + while (i < size) { + var curr = slab[i]; + + if (typeof curr === 'function') { + curr = Runtime.getFunctionIndex(curr); + } + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + assert(type, 'Must know what type to store in allocate!'); + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + i += Runtime.getNativeTypeSize(type); + } + + return ret; +} +Module['allocate'] = allocate; + +function Pointer_stringify(ptr, /* optional */ length) { + var utf8 = new Runtime.UTF8Processor(); + var nullTerminated = typeof(length) == "undefined"; + var ret = ""; + var i = 0; + var t; + while (1) { + t = HEAPU8[((ptr)+(i))]; + if (nullTerminated && t == 0) break; + ret += utf8.processCChar(t); + i += 1; + if (!nullTerminated && i == length) break; + } + return ret; +} +Module['Pointer_stringify'] = Pointer_stringify; + +function Array_stringify(array) { + var ret = ""; + for (var i = 0; i < array.length; i++) { + ret += String.fromCharCode(array[i]); + } + return ret; +} +Module['Array_stringify'] = Array_stringify; + +// Memory management + +var FUNCTION_TABLE; // XXX: In theory the indexes here can be equal to pointers to stacked or malloced memory. Such comparisons should + // be false, but can turn out true. We should probably set the top bit to prevent such issues. + +var PAGE_SIZE = 4096; +function alignMemoryPage(x) { + return ((x+4095)>>12)<<12; +} + +var HEAP; +var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + +var STACK_ROOT, STACKTOP, STACK_MAX; +var STATICTOP; +function enlargeMemory() { + abort('Cannot enlarge memory arrays. Adjust TOTAL_MEMORY (currently ' + TOTAL_MEMORY + ') or compile with ALLOW_MEMORY_GROWTH'); +} + +var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; +var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 10485760; +var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152; + +// Initialize the runtime's memory +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) + assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']), + 'Cannot fallback to non-typed array case: Code is too specialized'); + + var buffer = new ArrayBuffer(TOTAL_MEMORY); + HEAP8 = new Int8Array(buffer); + HEAP16 = new Int16Array(buffer); + HEAP32 = new Int32Array(buffer); + HEAPU8 = new Uint8Array(buffer); + HEAPU16 = new Uint16Array(buffer); + HEAPU32 = new Uint32Array(buffer); + HEAPF32 = new Float32Array(buffer); + HEAPF64 = new Float64Array(buffer); + + // Endianness check (note: assumes compiler arch was little-endian) + HEAP32[0] = 255; + assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system'); + +Module['HEAP'] = HEAP; +Module['HEAP8'] = HEAP8; +Module['HEAP16'] = HEAP16; +Module['HEAP32'] = HEAP32; +Module['HEAPU8'] = HEAPU8; +Module['HEAPU16'] = HEAPU16; +Module['HEAPU32'] = HEAPU32; +Module['HEAPF32'] = HEAPF32; +Module['HEAPF64'] = HEAPF64; + +STACK_ROOT = STACKTOP = Runtime.alignMemory(1); +STACK_MAX = STACK_ROOT + TOTAL_STACK; + +var tempDoublePtr = Runtime.alignMemory(STACK_MAX, 8); +var tempDoubleI8 = HEAP8.subarray(tempDoublePtr); +var tempDoubleI32 = HEAP32.subarray(tempDoublePtr >> 2); +var tempDoubleF32 = HEAPF32.subarray(tempDoublePtr >> 2); +var tempDoubleF64 = HEAPF64.subarray(tempDoublePtr >> 3); +function copyTempFloat(ptr) { // functions, because inlining this code is increases code size too much + tempDoubleI8[0] = HEAP8[ptr]; + tempDoubleI8[1] = HEAP8[ptr+1]; + tempDoubleI8[2] = HEAP8[ptr+2]; + tempDoubleI8[3] = HEAP8[ptr+3]; +} +function copyTempDouble(ptr) { + tempDoubleI8[0] = HEAP8[ptr]; + tempDoubleI8[1] = HEAP8[ptr+1]; + tempDoubleI8[2] = HEAP8[ptr+2]; + tempDoubleI8[3] = HEAP8[ptr+3]; + tempDoubleI8[4] = HEAP8[ptr+4]; + tempDoubleI8[5] = HEAP8[ptr+5]; + tempDoubleI8[6] = HEAP8[ptr+6]; + tempDoubleI8[7] = HEAP8[ptr+7]; +} +STACK_MAX = tempDoublePtr + 8; + +STATICTOP = alignMemoryPage(STACK_MAX); + +assert(STATICTOP < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY + +var nullString = allocate(intArrayFromString('(null)'), 'i8', ALLOC_STATIC); + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + var func = callback.func; + if (typeof func === 'number') { + func = FUNCTION_TABLE[func]; + } + func(callback.arg === undefined ? null : callback.arg); + } +} + +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown + +function initRuntime() { + callRuntimeCallbacks(__ATINIT__); +} +function preMain() { + callRuntimeCallbacks(__ATMAIN__); +} +function exitRuntime() { + callRuntimeCallbacks(__ATEXIT__); + + // Print summary of correction activity + CorrectionsMonitor.print(); +} + +function String_len(ptr) { + var i = ptr; + while (HEAP8[(i++)]) {}; // Note: should be |!= 0|, technically. But this helps catch bugs with undefineds + return i - ptr - 1; +} +Module['String_len'] = String_len; + +// Tools + +// This processes a JS string into a C-line array of numbers, 0-terminated. +// For LLVM-originating strings, see parser.js:parseLLVMString function +function intArrayFromString(stringy, dontAddNull, length /* optional */) { + var ret = (new Runtime.UTF8Processor()).processJSString(stringy); + if (length) { + ret.length = length; + } + if (!dontAddNull) { + ret.push(0); + } + return ret; +} +Module['intArrayFromString'] = intArrayFromString; + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} +Module['intArrayToString'] = intArrayToString; + +// Write a Javascript array to somewhere in the heap +function writeStringToMemory(string, buffer, dontAddNull) { + var array = intArrayFromString(string, dontAddNull); + var i = 0; + while (i < array.length) { + var chr = array[i]; + HEAP8[((buffer)+(i))]=chr + i = i + 1; + } +} +Module['writeStringToMemory'] = writeStringToMemory; + +function writeArrayToMemory(array, buffer) { + for (var i = 0; i < array.length; i++) { + HEAP8[((buffer)+(i))]=array[i]; + } +} +Module['writeArrayToMemory'] = writeArrayToMemory; + +var STRING_TABLE = []; + +function unSign(value, bits, ignore, sig) { + if (value >= 0) { + return value; + } + 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 + : Math.pow(2, bits) + value; + // TODO: clean up previous line +} +function reSign(value, bits, ignore, sig) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + 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 + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// PRE_RUN_ADDITIONS (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyTracking = {}; +var calledRun = false; +var runDependencyWatcher = null; +function addRunDependency(id) { + runDependencies++; + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval !== 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(function() { + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + Module.printErr('still waiting on run dependencies:'); + } + Module.printErr('dependency: ' + dep); + } + if (shown) { + Module.printErr('(end of list)'); + } + }, 6000); + } + } else { + Module.printErr('warning: run dependency added without ID'); + } +} +Module['addRunDependency'] = addRunDependency; +function removeRunDependency(id) { + runDependencies--; + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + Module.printErr('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (!calledRun) run(); + } +} +Module['removeRunDependency'] = removeRunDependency; + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + +// === Body === + + + + +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. + +function _ast_expression_init($self, $codegen) { + ; + var __label__; + + var $1; + var $2; + $1=$self; + $2=$codegen; + var $3=$2; + var $4=$1; + var $5=$4; + var $6=(($5+20)|0); + HEAP32[(($6)>>2)]=$3; + var $7=$1; + var $8=$7; + var $9=(($8+24)|0); + HEAP32[(($9)>>2)]=0; + var $10=$1; + var $11=$10; + var $12=(($11+28)|0); + HEAP32[(($12)>>2)]=0; + var $13=$1; + var $14=$13; + var $15=(($14+48)|0); + HEAP32[(($15)>>2)]=0; + var $16=$1; + var $17=$16; + var $18=(($17+52)|0); + HEAP32[(($18)>>2)]=0; + var $19=$1; + var $20=$19; + var $21=(($20+44)|0); + HEAP8[($21)]=0; + var $22=$1; + var $23=$22; + var $24=(($23+32)|0); + HEAP32[(($24)>>2)]=0; + var $25=$1; + var $26=$25; + var $27=(($26+36)|0); + HEAP32[(($27)>>2)]=0; + var $28=$1; + var $29=$28; + var $30=(($29+40)|0); + HEAP32[(($30)>>2)]=0; + ; + return; +} + + +function _ast_expression_common_params_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+36)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+40)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+40)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+40)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+40)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+40)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 93, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+32)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+36)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+32)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 93, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+32)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+36)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+32)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_expression_common_params_add["X"]=1; + +function _ast_value_copy($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $fromex; + var $selfex; + var $cp; + var $v; + $2=$self; + var $3=$2; + var $4=(($3)|0); + var $5=(($4)|0); + var $6=(($5)|0); + var $7=$2; + var $8=(($7+56)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=$2; + var $11=(($10)|0); + var $12=(($11+24)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($6)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($6+4)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=_ast_value_new($15, $17, $9, $13); + $cp=$18; + var $19=$2; + var $20=(($19)|0); + var $21=(($20+28)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22)|0)!=0; + if ($23) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $25=$2; + var $26=(($25)|0); + var $27=(($26)|0); + var $28=(($27)|0); + var $29=$2; + var $30=(($29)|0); + var $31=(($30+28)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=(($28)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($28+4)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=_ast_type_copy($34, $36, $32); + var $38=$cp; + var $39=(($38)|0); + var $40=(($39+28)|0); + HEAP32[(($40)>>2)]=$37; + var $41=$cp; + var $42=(($41)|0); + var $43=(($42+28)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($44)|0)!=0; + if ($45) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $47=$cp; + _ast_value_delete($47); + $1=0; + __label__ = 14; break; + case 5: + __label__ = 6; break; + case 6: + var $50=$2; + var $51=(($50)|0); + $fromex=$51; + var $52=$cp; + var $53=(($52)|0); + $selfex=$53; + var $54=$fromex; + var $55=(($54+44)|0); + var $56=HEAP8[($55)]; + var $57=(($56) & 1); + var $58=$selfex; + var $59=(($58+44)|0); + var $60=(($57)&1); + HEAP8[($59)]=$60; + $i=0; + __label__ = 7; break; + case 7: + var $62=$i; + var $63=$fromex; + var $64=(($63+36)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($62)>>>0) < (($65)>>>0); + if ($66) { __label__ = 8; break; } else { __label__ = 13; break; } + case 8: + var $68=$i; + var $69=$fromex; + var $70=(($69+32)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=(($71+($68<<2))|0); + var $73=HEAP32[(($72)>>2)]; + var $74=_ast_value_copy($73); + $v=$74; + var $75=$v; + var $76=(($75)|0)!=0; + if ($76) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $78=$selfex; + var $79=$v; + var $80=_ast_expression_common_params_add($78, $79); + if ($80) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $82=$cp; + _ast_value_delete($82); + $1=0; + __label__ = 14; break; + case 11: + __label__ = 12; break; + case 12: + var $85=$i; + var $86=((($85)+(1))|0); + $i=$86; + __label__ = 7; break; + case 13: + var $88=$cp; + $1=$88; + __label__ = 14; break; + case 14: + var $90=$1; + ; + return $90; + default: assert(0, "bad label: " + __label__); + } +} +_ast_value_copy["X"]=1; + +function _ast_value_new($ctx_0, $ctx_1, $name, $t) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $self; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$name; + $3=$t; + var $6=_util_memory_a(84, 303, ((STRING_TABLE.__str)|0)); + var $7=$6; + $self=$7; + var $8=$self; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 8; break; + case 4: + var $12=$self; + var $13=$12; + var $14=(($ctx)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($ctx+4)|0); + var $17=HEAP32[(($16)>>2)]; + _ast_node_init($13, $15, $17, 2); + var $18=$self; + var $19=$18; + var $20=$19; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=(30); + var $22=$self; + var $23=$22; + _ast_expression_init($23, (6)); + var $24=$self; + var $25=(($24)|0); + var $26=(($25)|0); + var $27=(($26+16)|0); + HEAP8[($27)]=1; + var $28=$2; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $31=$2; + var $32=_util_strdup($31); + var $35 = $32;__label__ = 7; break; + case 6: + var $35 = 0;__label__ = 7; break; + case 7: + var $35; + var $36=$self; + var $37=(($36+56)|0); + HEAP32[(($37)>>2)]=$35; + var $38=$3; + var $39=$self; + var $40=(($39)|0); + var $41=(($40+24)|0); + HEAP32[(($41)>>2)]=$38; + var $42=$self; + var $43=(($42)|0); + var $44=(($43+28)|0); + HEAP32[(($44)>>2)]=0; + var $45=$self; + var $46=(($45+60)|0); + HEAP8[($46)]=0; + var $47=$self; + var $48=(($47+76)|0); + HEAP32[(($48)>>2)]=0; + var $49=$self; + var $50=(($49+64)|0); + var $51=$50; + HEAP32[(($51)>>2)]=0; HEAP32[((($51)+(4))>>2)]=0; HEAP32[((($51)+(8))>>2)]=0; + var $52=$self; + var $53=(($52+80)|0); + HEAP32[(($53)>>2)]=0; + var $54=$self; + $1=$54; + __label__ = 8; break; + case 8: + var $56=$1; + STACKTOP = __stackBase__; + return $56; + default: assert(0, "bad label: " + __label__); + } +} +_ast_value_new["X"]=1; + +function _ast_type_copy($ctx_0, $ctx_1, $ex) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $i; + var $fromex; + var $selfex; + var $self; + var $v; + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $2=$ex; + var $5=$2; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 19; break; + case 4: + var $9=_util_memory_a(92, 163, ((STRING_TABLE.__str)|0)); + var $10=$9; + $self=$10; + var $11=$self; + var $12=(($11)|0)!=0; + if ($12) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 19; break; + case 6: + var $15=$self; + var $16=$15; + var $17=(($ctx)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($ctx+4)|0); + var $20=HEAP32[(($19)>>2)]; + _ast_node_init($16, $18, $20, 1); + var $21=$self; + var $22=$21; + var $23=$22; + var $24=(($23+8)|0); + HEAP32[(($24)>>2)]=(22); + var $25=$self; + _ast_expression_init($25, 0); + var $26=$2; + var $27=$26; + $fromex=$27; + var $28=$self; + var $29=$28; + $selfex=$29; + var $30=$selfex; + var $31=(($30+20)|0); + HEAP32[(($31)>>2)]=0; + var $32=$fromex; + var $33=(($32+24)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$selfex; + var $36=(($35+24)|0); + HEAP32[(($36)>>2)]=$34; + var $37=$fromex; + var $38=(($37+28)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($39)|0)!=0; + if ($40) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $42=$fromex; + var $43=(($42+28)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($ctx)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($ctx+4)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=_ast_type_copy($46, $48, $44); + var $50=$selfex; + var $51=(($50+28)|0); + HEAP32[(($51)>>2)]=$49; + var $52=$selfex; + var $53=(($52+28)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=(($54)|0)!=0; + if ($55) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $57=$self; + _ast_expression_delete_full($57); + $1=0; + __label__ = 19; break; + case 9: + __label__ = 11; break; + case 10: + var $60=$selfex; + var $61=(($60+28)|0); + HEAP32[(($61)>>2)]=0; + __label__ = 11; break; + case 11: + var $63=$fromex; + var $64=(($63+44)|0); + var $65=HEAP8[($64)]; + var $66=(($65) & 1); + var $67=$selfex; + var $68=(($67+44)|0); + var $69=(($66)&1); + HEAP8[($68)]=$69; + $i=0; + __label__ = 12; break; + case 12: + var $71=$i; + var $72=$fromex; + var $73=(($72+36)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($71)>>>0) < (($74)>>>0); + if ($75) { __label__ = 13; break; } else { __label__ = 18; break; } + case 13: + var $77=$i; + var $78=$fromex; + var $79=(($78+32)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=(($80+($77<<2))|0); + var $82=HEAP32[(($81)>>2)]; + var $83=_ast_value_copy($82); + $v=$83; + var $84=$v; + var $85=(($84)|0)!=0; + if ($85) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + var $87=$selfex; + var $88=$v; + var $89=_ast_expression_common_params_add($87, $88); + if ($89) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $91=$self; + _ast_expression_delete_full($91); + $1=0; + __label__ = 19; break; + case 16: + __label__ = 17; break; + case 17: + var $94=$i; + var $95=((($94)+(1))|0); + $i=$95; + __label__ = 12; break; + case 18: + var $97=$self; + $1=$97; + __label__ = 19; break; + case 19: + var $99=$1; + STACKTOP = __stackBase__; + return $99; + default: assert(0, "bad label: " + __label__); + } +} +_ast_type_copy["X"]=1; + +function _ast_value_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + var $2=$1; + var $3=(($2+56)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7+56)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 323, ((STRING_TABLE.__str)|0)); + __label__ = 4; break; + case 4: + var $11=$1; + var $12=(($11+60)|0); + var $13=HEAP8[($12)]; + var $14=(($13) & 1); + if ($14) { __label__ = 5; break; } else { __label__ = 10; break; } + case 5: + var $16=$1; + var $17=(($16)|0); + var $18=(($17+24)|0); + var $19=HEAP32[(($18)>>2)]; + if ((($19)|0) == 1) { + __label__ = 6; break; + } + else if ((($19)|0) == 6) { + __label__ = 7; break; + } + else { + __label__ = 8; break; + } + + case 6: + var $21=$1; + var $22=(($21+64)|0); + var $23=$22; + var $24=HEAP32[(($23)>>2)]; + _util_memory_d($24, 328, ((STRING_TABLE.__str)|0)); + __label__ = 9; break; + case 7: + var $26=$1; + var $27=(($26+64)|0); + var $28=$27; + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+20)|0); + HEAP32[(($30)>>2)]=0; + __label__ = 9; break; + case 8: + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $34=$1; + var $35=$34; + _ast_expression_delete($35); + var $36=$1; + var $37=$36; + _util_memory_d($37, 342, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_type_adopt_impl($self, $other) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $fromex; + var $selfex; + var $v; + $2=$self; + $3=$other; + var $4=$3; + var $5=$4; + var $6=(($5+24)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=$8; + var $10=(($9+24)|0); + HEAP32[(($10)>>2)]=$7; + var $11=$3; + var $12=$11; + var $13=(($12+28)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $17=$2; + var $18=$17; + var $19=(($18)|0); + var $20=$3; + var $21=$20; + var $22=(($21+28)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($19)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($19+4)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=_ast_type_copy($25, $27, $23); + var $29=$2; + var $30=$29; + var $31=(($30+28)|0); + HEAP32[(($31)>>2)]=$28; + var $32=$2; + var $33=$32; + var $34=(($33+28)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)!=0; + if ($36) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 14; break; + case 5: + __label__ = 6; break; + case 6: + var $40=$3; + var $41=$40; + $fromex=$41; + var $42=$2; + var $43=$42; + $selfex=$43; + var $44=$fromex; + var $45=(($44+44)|0); + var $46=HEAP8[($45)]; + var $47=(($46) & 1); + var $48=$selfex; + var $49=(($48+44)|0); + var $50=(($47)&1); + HEAP8[($49)]=$50; + $i=0; + __label__ = 7; break; + case 7: + var $52=$i; + var $53=$fromex; + var $54=(($53+36)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($52)>>>0) < (($55)>>>0); + if ($56) { __label__ = 8; break; } else { __label__ = 13; break; } + case 8: + var $58=$i; + var $59=$fromex; + var $60=(($59+32)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61+($58<<2))|0); + var $63=HEAP32[(($62)>>2)]; + var $64=_ast_value_copy($63); + $v=$64; + var $65=$v; + var $66=(($65)|0)!=0; + if ($66) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $68=$selfex; + var $69=$v; + var $70=_ast_expression_common_params_add($68, $69); + if ($70) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 14; break; + case 11: + __label__ = 12; break; + case 12: + var $74=$i; + var $75=((($74)+(1))|0); + $i=$75; + __label__ = 7; break; + case 13: + $1=1; + __label__ = 14; break; + case 14: + var $78=$1; + ; + return $78; + default: assert(0, "bad label: " + __label__); + } +} +_ast_type_adopt_impl["X"]=1; + +function _ast_node_init($self, $ctx_0, $ctx_1, $nodetype) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $ctx=__stackBase__; + var $2; + $1=$self; + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $2=$nodetype; + var $5=$1; + var $6=$5; + var $7=(($6)|0); + var $8=$7; + var $9=$ctx; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($8)>>2)]=HEAP32[(($9)>>2)];HEAP32[((($8)+(4))>>2)]=HEAP32[((($9)+(4))>>2)]; + var $10=$1; + var $11=$10; + var $12=(($11+8)|0); + HEAP32[(($12)>>2)]=8; + var $13=$1; + var $14=$13; + var $15=(($14+16)|0); + HEAP8[($15)]=0; + var $16=$2; + var $17=$1; + var $18=$17; + var $19=(($18+12)|0); + HEAP32[(($19)>>2)]=$16; + STACKTOP = __stackBase__; + return; +} + + +function _ast_expression_delete_full($self) { + ; + var __label__; + + var $1; + $1=$self; + var $2=$1; + _ast_expression_delete($2); + var $3=$1; + var $4=$3; + _util_memory_d($4, 90, ((STRING_TABLE.__str)|0)); + ; + return; +} + + +function _ast_compare_type($a, $b) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$a; + $3=$b; + var $4=$2; + var $5=$4; + var $6=(($5+24)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$3; + var $9=$8; + var $10=(($9+24)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($7)|0)!=(($11)|0); + if ($12) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 21; break; + case 4: + var $15=$2; + var $16=$15; + var $17=(($16+28)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=(($20)&1); + var $22=$3; + var $23=$22; + var $24=(($23+28)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)!=0; + var $27=$26 ^ 1; + var $28=(($27)&1); + var $29=(($21)|0)!=(($28)|0); + if ($29) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 21; break; + case 6: + var $32=$2; + var $33=$32; + var $34=(($33+36)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$3; + var $37=$36; + var $38=(($37+36)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($35)|0)!=(($39)|0); + if ($40) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + $1=0; + __label__ = 21; break; + case 8: + var $43=$2; + var $44=$43; + var $45=(($44+44)|0); + var $46=HEAP8[($45)]; + var $47=(($46) & 1); + var $48=(($47)&1); + var $49=$3; + var $50=$49; + var $51=(($50+44)|0); + var $52=HEAP8[($51)]; + var $53=(($52) & 1); + var $54=(($53)&1); + var $55=(($48)|0)!=(($54)|0); + if ($55) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + $1=0; + __label__ = 21; break; + case 10: + var $58=$2; + var $59=$58; + var $60=(($59+36)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61)|0)!=0; + if ($62) { __label__ = 11; break; } else { __label__ = 18; break; } + case 11: + $i=0; + __label__ = 12; break; + case 12: + var $65=$i; + var $66=$2; + var $67=$66; + var $68=(($67+36)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=(($65)>>>0) < (($69)>>>0); + if ($70) { __label__ = 13; break; } else { __label__ = 17; break; } + case 13: + var $72=$i; + var $73=$2; + var $74=$73; + var $75=(($74+32)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($76+($72<<2))|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$78; + var $80=$i; + var $81=$3; + var $82=$81; + var $83=(($82+32)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=(($84+($80<<2))|0); + var $86=HEAP32[(($85)>>2)]; + var $87=$86; + var $88=_ast_compare_type($79, $87); + if ($88) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + $1=0; + __label__ = 21; break; + case 15: + __label__ = 16; break; + case 16: + var $92=$i; + var $93=((($92)+(1))|0); + $i=$93; + __label__ = 12; break; + case 17: + __label__ = 18; break; + case 18: + var $96=$2; + var $97=$96; + var $98=(($97+28)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=(($99)|0)!=0; + if ($100) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $102=$2; + var $103=$102; + var $104=(($103+28)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=$3; + var $107=$106; + var $108=(($107+28)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=_ast_compare_type($105, $109); + $1=$110; + __label__ = 21; break; + case 20: + $1=1; + __label__ = 21; break; + case 21: + var $113=$1; + ; + return $113; + default: assert(0, "bad label: " + __label__); + } +} +_ast_compare_type["X"]=1; + +function _ast_type_to_string($e, $buf, $bufsize) { + ; + var __label__; + + var $1; + var $2; + var $3; + var $pos; + $1=$e; + $2=$buf; + $3=$bufsize; + var $4=$1; + var $5=$2; + var $6=$3; + var $7=((($6)-(1))|0); + var $8=_ast_type_to_string_impl($4, $5, $7, 0); + $pos=$8; + var $9=$pos; + var $10=$2; + var $11=(($10+$9)|0); + HEAP8[($11)]=0; + ; + return; +} + + +function _ast_type_to_string_impl($e, $buf, $bufsize, $pos) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $typestr; + var $typelen; + var $i; + $2=$e; + $3=$buf; + $4=$bufsize; + $5=$pos; + var $6=$2; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 6; break; } else { __label__ = 3; break; } + case 3: + var $9=$5; + var $10=((($9)+(6))|0); + var $11=$4; + var $12=(($10)>>>0) >= (($11)>>>0); + if ($12) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + __label__ = 32; break; + case 5: + var $15=$3; + var $16=$5; + var $17=(($15+$16)|0); + var $18=_strcpy($17, ((STRING_TABLE.__str109)|0)); + var $19=$5; + var $20=((($19)+(6))|0); + $1=$20; + __label__ = 33; break; + case 6: + var $22=$5; + var $23=((($22)+(1))|0); + var $24=$4; + var $25=(($23)>>>0) >= (($24)>>>0); + if ($25) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + __label__ = 32; break; + case 8: + var $28=$2; + var $29=$28; + var $30=(($29+24)|0); + var $31=HEAP32[(($30)>>2)]; + if ((($31)|0) == 9) { + __label__ = 9; break; + } + else if ((($31)|0) == 5) { + __label__ = 10; break; + } + else if ((($31)|0) == 7) { + __label__ = 11; break; + } + else if ((($31)|0) == 6) { + __label__ = 16; break; + } + else { + __label__ = 29; break; + } + + case 9: + var $33=$3; + var $34=$5; + var $35=(($33+$34)|0); + var $36=_strcpy($35, ((STRING_TABLE.__str110)|0)); + var $37=$5; + var $38=((($37)+(9))|0); + $1=$38; + __label__ = 33; break; + case 10: + var $40=$5; + var $41=((($40)+(1))|0); + $5=$41; + var $42=$3; + var $43=(($42+$40)|0); + HEAP8[($43)]=46; + var $44=$2; + var $45=$44; + var $46=(($45+28)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$3; + var $49=$4; + var $50=$5; + var $51=_ast_type_to_string_impl($47, $48, $49, $50); + $1=$51; + __label__ = 33; break; + case 11: + var $53=$5; + var $54=((($53)+(3))|0); + var $55=$4; + var $56=(($54)>>>0) >= (($55)>>>0); + if ($56) { __label__ = 12; break; } else { __label__ = 13; break; } + case 12: + __label__ = 32; break; + case 13: + var $59=$5; + var $60=((($59)+(1))|0); + $5=$60; + var $61=$3; + var $62=(($61+$59)|0); + HEAP8[($62)]=42; + var $63=$5; + var $64=((($63)+(1))|0); + $5=$64; + var $65=$3; + var $66=(($65+$63)|0); + HEAP8[($66)]=40; + var $67=$2; + var $68=$67; + var $69=(($68+28)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$3; + var $72=$4; + var $73=$5; + var $74=_ast_type_to_string_impl($70, $71, $72, $73); + $5=$74; + var $75=$5; + var $76=((($75)+(1))|0); + var $77=$4; + var $78=(($76)>>>0) >= (($77)>>>0); + if ($78) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + __label__ = 32; break; + case 15: + var $81=$5; + var $82=((($81)+(1))|0); + $5=$82; + var $83=$3; + var $84=(($83+$81)|0); + HEAP8[($84)]=41; + var $85=$5; + $1=$85; + __label__ = 33; break; + case 16: + var $87=$2; + var $88=$87; + var $89=(($88+28)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=$3; + var $92=$4; + var $93=$5; + var $94=_ast_type_to_string_impl($90, $91, $92, $93); + $5=$94; + var $95=$5; + var $96=((($95)+(2))|0); + var $97=$4; + var $98=(($96)>>>0) >= (($97)>>>0); + if ($98) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + __label__ = 32; break; + case 18: + var $101=$2; + var $102=$101; + var $103=(($102+36)|0); + var $104=HEAP32[(($103)>>2)]; + var $105=(($104)|0)==0; + if ($105) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $107=$5; + var $108=((($107)+(1))|0); + $5=$108; + var $109=$3; + var $110=(($109+$107)|0); + HEAP8[($110)]=40; + var $111=$5; + var $112=((($111)+(1))|0); + $5=$112; + var $113=$3; + var $114=(($113+$111)|0); + HEAP8[($114)]=41; + var $115=$5; + $1=$115; + __label__ = 33; break; + case 20: + var $117=$5; + var $118=((($117)+(1))|0); + $5=$118; + var $119=$3; + var $120=(($119+$117)|0); + HEAP8[($120)]=40; + var $121=$2; + var $122=$121; + var $123=(($122+32)|0); + var $124=HEAP32[(($123)>>2)]; + var $125=(($124)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=$126; + var $128=$3; + var $129=$4; + var $130=$5; + var $131=_ast_type_to_string_impl($127, $128, $129, $130); + $5=$131; + $i=1; + __label__ = 21; break; + case 21: + var $133=$i; + var $134=$2; + var $135=$134; + var $136=(($135+36)|0); + var $137=HEAP32[(($136)>>2)]; + var $138=(($133)>>>0) < (($137)>>>0); + if ($138) { __label__ = 22; break; } else { __label__ = 26; break; } + case 22: + var $140=$5; + var $141=((($140)+(2))|0); + var $142=$4; + var $143=(($141)>>>0) >= (($142)>>>0); + if ($143) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + __label__ = 32; break; + case 24: + var $146=$5; + var $147=((($146)+(1))|0); + $5=$147; + var $148=$3; + var $149=(($148+$146)|0); + HEAP8[($149)]=44; + var $150=$5; + var $151=((($150)+(1))|0); + $5=$151; + var $152=$3; + var $153=(($152+$150)|0); + HEAP8[($153)]=32; + var $154=$i; + var $155=$2; + var $156=$155; + var $157=(($156+32)|0); + var $158=HEAP32[(($157)>>2)]; + var $159=(($158+($154<<2))|0); + var $160=HEAP32[(($159)>>2)]; + var $161=$160; + var $162=$3; + var $163=$4; + var $164=$5; + var $165=_ast_type_to_string_impl($161, $162, $163, $164); + $5=$165; + __label__ = 25; break; + case 25: + var $167=$i; + var $168=((($167)+(1))|0); + $i=$168; + __label__ = 21; break; + case 26: + var $170=$5; + var $171=((($170)+(1))|0); + var $172=$4; + var $173=(($171)>>>0) >= (($172)>>>0); + if ($173) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + __label__ = 32; break; + case 28: + var $176=$5; + var $177=((($176)+(1))|0); + $5=$177; + var $178=$3; + var $179=(($178+$176)|0); + HEAP8[($179)]=41; + var $180=$5; + $1=$180; + __label__ = 33; break; + case 29: + var $182=$2; + var $183=$182; + var $184=(($183+24)|0); + var $185=HEAP32[(($184)>>2)]; + var $186=((_type_name+($185<<2))|0); + var $187=HEAP32[(($186)>>2)]; + $typestr=$187; + var $188=$typestr; + var $189=_strlen($188); + $typelen=$189; + var $190=$5; + var $191=$typelen; + var $192=((($190)+($191))|0); + var $193=$4; + var $194=(($192)>>>0) >= (($193)>>>0); + if ($194) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + __label__ = 32; break; + case 31: + var $197=$3; + var $198=$5; + var $199=(($197+$198)|0); + var $200=$typestr; + var $201=_strcpy($199, $200); + var $202=$5; + var $203=$typelen; + var $204=((($202)+($203))|0); + $1=$204; + __label__ = 33; break; + case 32: + var $206=$4; + var $207=((($206)-(3))|0); + var $208=$3; + var $209=(($208+$207)|0); + HEAP8[($209)]=46; + var $210=$4; + var $211=((($210)-(2))|0); + var $212=$3; + var $213=(($212+$211)|0); + HEAP8[($213)]=46; + var $214=$4; + var $215=((($214)-(1))|0); + var $216=$3; + var $217=(($216+$215)|0); + HEAP8[($217)]=46; + var $218=$4; + $1=$218; + __label__ = 33; break; + case 33: + var $220=$1; + ; + return $220; + default: assert(0, "bad label: " + __label__); + } +} +_ast_type_to_string_impl["X"]=1; + +function _ast_value_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$2; + var $8=(($7+80)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $12=$2; + var $13=$12; + var $14=(($13)|0); + var $15=$2; + var $16=(($15+56)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($14)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($14+4)|0); + var $21=HEAP32[(($20)>>2)]; + _asterror($19, $21, ((STRING_TABLE.__str4)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$17,tempInt)); + $1=0; + __label__ = 5; break; + case 4: + var $23=$2; + var $24=(($23+80)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=$5; + HEAP32[(($26)>>2)]=$25; + $1=1; + __label__ = 5; break; + case 5: + var $28=$1; + STACKTOP = __stackBase__; + return $28; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_expression_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=$2; + var $4=(($3+28)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=$8; + var $10=(($9+28)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=$11; + var $13=$12; + var $14=(($13+8)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$1; + var $17=$16; + var $18=(($17+28)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$19; + FUNCTION_TABLE[$15]($20); + __label__ = 4; break; + case 4: + $i=0; + __label__ = 5; break; + case 5: + var $23=$i; + var $24=$1; + var $25=$24; + var $26=(($25+36)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($23)>>>0) < (($27)>>>0); + if ($28) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $30=$i; + var $31=$1; + var $32=$31; + var $33=(($32+32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($34+($30<<2))|0); + var $36=HEAP32[(($35)>>2)]; + var $37=$36; + var $38=$37; + var $39=(($38+8)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$i; + var $42=$1; + var $43=$42; + var $44=(($43+32)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($45+($41<<2))|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + FUNCTION_TABLE[$40]($48); + __label__ = 7; break; + case 7: + var $50=$i; + var $51=((($50)+(1))|0); + $i=$51; + __label__ = 5; break; + case 8: + var $53=$1; + var $54=$53; + var $55=(($54+32)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $59=$1; + var $60=$59; + var $61=(($60+32)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=$62; + _util_memory_d($63, 84, ((STRING_TABLE.__str)|0)); + __label__ = 10; break; + case 10: + var $65=$1; + var $66=$65; + var $67=(($66+32)|0); + HEAP32[(($67)>>2)]=0; + var $68=$1; + var $69=$68; + var $70=(($69+36)|0); + HEAP32[(($70)>>2)]=0; + var $71=$1; + var $72=$71; + var $73=(($72+40)|0); + HEAP32[(($73)>>2)]=0; + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_expression_delete["X"]=1; + +function _ast_value_set_name($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$name; + var $3=$1; + var $4=(($3+56)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=(($8+56)|0); + var $10=HEAP32[(($9)>>2)]; + _util_memory_d($10, 353, ((STRING_TABLE.__str)|0)); + __label__ = 4; break; + case 4: + var $12=$2; + var $13=_util_strdup($12); + var $14=$1; + var $15=(($14+56)|0); + HEAP32[(($15)>>2)]=$13; + var $16=$1; + var $17=(($16+56)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=$20 ^ 1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_binary_new($ctx_0, $ctx_1, $op, $left, $right) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $4; + var $self; + var $5=(($ctx)|0); + HEAP32[(($5)>>2)]=$ctx_0; + var $6=(($ctx+4)|0); + HEAP32[(($6)>>2)]=$ctx_1; + $2=$op; + $3=$left; + $4=$right; + var $7=_util_memory_a(68, 361, ((STRING_TABLE.__str)|0)); + var $8=$7; + $self=$8; + var $9=$self; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 22; break; + case 4: + var $13=$self; + var $14=$13; + var $15=(($ctx)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($ctx+4)|0); + var $18=HEAP32[(($17)>>2)]; + _ast_node_init($14, $16, $18, 5); + var $19=$self; + var $20=$19; + var $21=$20; + var $22=(($21+8)|0); + HEAP32[(($22)>>2)]=(44); + var $23=$self; + var $24=$23; + _ast_expression_init($24, (36)); + var $25=$2; + var $26=$self; + var $27=(($26+56)|0); + HEAP32[(($27)>>2)]=$25; + var $28=$3; + var $29=$self; + var $30=(($29+60)|0); + HEAP32[(($30)>>2)]=$28; + var $31=$4; + var $32=$self; + var $33=(($32+64)|0); + HEAP32[(($33)>>2)]=$31; + var $34=$2; + var $35=(($34)|0) >= 10; + if ($35) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $37=$2; + var $38=(($37)|0) <= 23; + if ($38) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $40=$self; + var $41=(($40)|0); + var $42=(($41+24)|0); + HEAP32[(($42)>>2)]=2; + __label__ = 21; break; + case 7: + var $44=$2; + var $45=(($44)|0)==62; + if ($45) { __label__ = 11; break; } else { __label__ = 8; break; } + case 8: + var $47=$2; + var $48=(($47)|0)==63; + if ($48) { __label__ = 11; break; } else { __label__ = 9; break; } + case 9: + var $50=$2; + var $51=(($50)|0)==64; + if ($51) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $53=$2; + var $54=(($53)|0)==65; + if ($54) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $56=$self; + var $57=(($56)|0); + var $58=(($57+24)|0); + HEAP32[(($58)>>2)]=2; + __label__ = 20; break; + case 12: + var $60=$2; + var $61=(($60)|0)==4; + if ($61) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + var $63=$2; + var $64=(($63)|0)==3; + if ($64) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + var $66=$self; + var $67=(($66)|0); + var $68=(($67+24)|0); + HEAP32[(($68)>>2)]=3; + __label__ = 19; break; + case 15: + var $70=$2; + var $71=(($70)|0)==2; + if ($71) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + var $73=$self; + var $74=(($73)|0); + var $75=(($74+24)|0); + HEAP32[(($75)>>2)]=2; + __label__ = 18; break; + case 17: + var $77=$3; + var $78=$77; + var $79=(($78+24)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=$self; + var $82=(($81)|0); + var $83=(($82+24)|0); + HEAP32[(($83)>>2)]=$80; + __label__ = 18; break; + case 18: + __label__ = 19; break; + case 19: + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + var $88=$self; + $1=$88; + __label__ = 22; break; + case 22: + var $90=$1; + STACKTOP = __stackBase__; + return $90; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binary_new["X"]=1; + +function _ast_binary_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+60)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+60)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + var $26=$1; + var $27=(($26+64)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$28; + var $30=$29; + var $31=(($30+16)|0); + var $32=HEAP8[($31)]; + var $33=(($32) & 1); + if ($33) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $35=$1; + var $36=(($35+64)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=$38; + var $40=(($39+8)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$1; + var $43=(($42+64)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$44; + FUNCTION_TABLE[$41]($45); + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $48=$1; + var $49=$48; + _ast_expression_delete($49); + var $50=$1; + var $51=$50; + _util_memory_d($51, 388, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binary_delete["X"]=1; + +function _ast_binary_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $left=__stackBase__; + var $right=(__stackBase__)+(4); + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((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)); + $1=0; + __label__ = 13; break; + case 4: + var $18=$2; + var $19=(($18)|0); + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $24=$2; + var $25=(($24)|0); + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$5; + HEAP32[(($28)>>2)]=$27; + $1=1; + __label__ = 13; break; + case 6: + var $30=$2; + var $31=(($30+60)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$32; + var $34=(($33+20)|0); + var $35=HEAP32[(($34)>>2)]; + $cgen=$35; + var $36=$cgen; + var $37=$2; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$3; + var $41=FUNCTION_TABLE[$36]($39, $40, 0, $left); + if ($41) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 13; break; + case 8: + var $44=$2; + var $45=(($44+64)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + var $48=(($47+20)|0); + var $49=HEAP32[(($48)>>2)]; + $cgen=$49; + var $50=$cgen; + var $51=$2; + var $52=(($51+64)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=$3; + var $55=FUNCTION_TABLE[$50]($53, $54, 0, $right); + if ($55) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 13; break; + case 10: + var $58=$3; + var $59=(($58+36)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=$3; + var $62=_ast_function_label($61, ((STRING_TABLE.__str16)|0)); + var $63=$2; + var $64=(($63+56)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=HEAP32[(($left)>>2)]; + var $67=HEAP32[(($right)>>2)]; + var $68=_ir_block_create_binop($60, $62, $65, $66, $67); + var $69=$5; + HEAP32[(($69)>>2)]=$68; + var $70=$5; + var $71=HEAP32[(($70)>>2)]; + var $72=(($71)|0)!=0; + if ($72) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 13; break; + case 12: + var $75=$5; + var $76=HEAP32[(($75)>>2)]; + var $77=$2; + var $78=(($77)|0); + var $79=(($78+52)|0); + HEAP32[(($79)>>2)]=$76; + $1=1; + __label__ = 13; break; + case 13: + var $81=$1; + STACKTOP = __stackBase__; + return $81; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binary_codegen["X"]=1; + +function _ast_binstore_new($ctx_0, $ctx_1, $storop, $op, $left, $right) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $4; + var $5; + var $self; + var $6=(($ctx)|0); + HEAP32[(($6)>>2)]=$ctx_0; + var $7=(($ctx+4)|0); + HEAP32[(($7)>>2)]=$ctx_1; + $2=$storop; + $3=$op; + $4=$left; + $5=$right; + var $8=_util_memory_a(72, 394, ((STRING_TABLE.__str)|0)); + var $9=$8; + $self=$9; + var $10=$self; + var $11=(($10)|0)!=0; + if ($11) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 10; break; + case 4: + var $14=$self; + var $15=$14; + var $16=(($ctx)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($ctx+4)|0); + var $19=HEAP32[(($18)>>2)]; + _ast_node_init($15, $17, $19, 7); + var $20=$self; + var $21=$20; + var $22=$21; + var $23=(($22+8)|0); + HEAP32[(($23)>>2)]=(40); + var $24=$self; + var $25=$24; + _ast_expression_init($25, (16)); + var $26=$2; + var $27=$self; + var $28=(($27+56)|0); + HEAP32[(($28)>>2)]=$26; + var $29=$3; + var $30=$self; + var $31=(($30+60)|0); + HEAP32[(($31)>>2)]=$29; + var $32=$4; + var $33=$self; + var $34=(($33+64)|0); + HEAP32[(($34)>>2)]=$32; + var $35=$5; + var $36=$self; + var $37=(($36+68)|0); + HEAP32[(($37)>>2)]=$35; + var $38=$4; + var $39=$38; + var $40=(($39+24)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$self; + var $43=(($42)|0); + var $44=(($43+24)|0); + HEAP32[(($44)>>2)]=$41; + var $45=$4; + var $46=$45; + var $47=(($46+28)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48)|0)!=0; + if ($49) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $51=$4; + var $52=(($ctx)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($ctx+4)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=_ast_type_copy($53, $55, $51); + var $57=$self; + var $58=(($57)|0); + var $59=(($58+28)|0); + HEAP32[(($59)>>2)]=$56; + var $60=$self; + var $61=(($60)|0); + var $62=(($61+28)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63)|0)!=0; + if ($64) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $66=$self; + var $67=$66; + var $68=$67; + var $69=(($68+8)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$self; + var $72=$71; + FUNCTION_TABLE[$70]($72); + $1=0; + __label__ = 10; break; + case 7: + __label__ = 9; break; + case 8: + var $75=$self; + var $76=(($75)|0); + var $77=(($76+28)|0); + HEAP32[(($77)>>2)]=0; + __label__ = 9; break; + case 9: + var $79=$self; + $1=$79; + __label__ = 10; break; + case 10: + var $81=$1; + STACKTOP = __stackBase__; + return $81; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binstore_new["X"]=1; + +function _ast_binstore_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+64)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+64)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+64)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + var $26=$1; + var $27=(($26+68)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$28; + var $30=$29; + var $31=(($30+16)|0); + var $32=HEAP8[($31)]; + var $33=(($32) & 1); + if ($33) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $35=$1; + var $36=(($35+68)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=$38; + var $40=(($39+8)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$1; + var $43=(($42+68)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$44; + FUNCTION_TABLE[$41]($45); + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $48=$1; + var $49=$48; + _ast_expression_delete($49); + var $50=$1; + var $51=$50; + _util_memory_d($51, 421, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binstore_delete["X"]=1; + +function _ast_binstore_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $leftl=__stackBase__; + var $leftr=(__stackBase__)+(4); + var $right=(__stackBase__)+(8); + var $bin; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $10=$2; + var $11=(($10)|0); + var $12=(($11+48)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $16=$2; + var $17=(($16)|0); + var $18=(($17+48)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$5; + HEAP32[(($20)>>2)]=$19; + $1=1; + __label__ = 20; break; + case 5: + var $22=$4; + var $23=(($22) & 1); + if ($23) { __label__ = 8; break; } else { __label__ = 6; break; } + case 6: + var $25=$2; + var $26=(($25)|0); + var $27=(($26+52)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $31=$2; + var $32=(($31)|0); + var $33=(($32+52)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$5; + HEAP32[(($35)>>2)]=$34; + $1=1; + __label__ = 20; break; + case 8: + var $37=$2; + var $38=(($37+64)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + $cgen=$42; + var $43=$cgen; + var $44=$2; + var $45=(($44+64)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$3; + var $48=FUNCTION_TABLE[$43]($46, $47, 0, $leftr); + if ($48) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 20; break; + case 10: + var $51=$2; + var $52=(($51+68)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=$53; + var $55=(($54+20)|0); + var $56=HEAP32[(($55)>>2)]; + $cgen=$56; + var $57=$cgen; + var $58=$2; + var $59=(($58+68)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=$3; + var $62=FUNCTION_TABLE[$57]($60, $61, 0, $right); + if ($62) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 20; break; + case 12: + var $65=$3; + var $66=(($65+36)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$3; + var $69=_ast_function_label($68, ((STRING_TABLE.__str17)|0)); + var $70=$2; + var $71=(($70+60)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=HEAP32[(($leftr)>>2)]; + var $74=HEAP32[(($right)>>2)]; + var $75=_ir_block_create_binop($67, $69, $72, $73, $74); + $bin=$75; + var $76=$bin; + var $77=$2; + var $78=(($77)|0); + var $79=(($78+52)|0); + HEAP32[(($79)>>2)]=$76; + var $80=$2; + var $81=(($80+64)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=$82; + var $84=(($83+20)|0); + var $85=HEAP32[(($84)>>2)]; + $cgen=$85; + var $86=$cgen; + var $87=$2; + var $88=(($87+64)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=$3; + var $91=FUNCTION_TABLE[$86]($89, $90, 1, $leftl); + if ($91) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + $1=0; + __label__ = 20; break; + case 14: + var $94=HEAP32[(($leftl)>>2)]; + var $95=$2; + var $96=(($95)|0); + var $97=(($96+48)|0); + HEAP32[(($97)>>2)]=$94; + var $98=$3; + var $99=(($98+36)|0); + var $100=HEAP32[(($99)>>2)]; + var $101=$2; + var $102=(($101+56)|0); + var $103=HEAP32[(($102)>>2)]; + var $104=HEAP32[(($leftl)>>2)]; + var $105=$bin; + var $106=_ir_block_create_store_op($100, $103, $104, $105); + if ($106) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 20; break; + case 16: + var $109=$bin; + var $110=$2; + var $111=(($110)|0); + var $112=(($111+52)|0); + HEAP32[(($112)>>2)]=$109; + var $113=$4; + var $114=(($113) & 1); + if ($114) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $116=HEAP32[(($leftl)>>2)]; + var $120 = $116;__label__ = 19; break; + case 18: + var $118=$bin; + var $120 = $118;__label__ = 19; break; + case 19: + var $120; + var $121=$5; + HEAP32[(($121)>>2)]=$120; + $1=1; + __label__ = 20; break; + case 20: + var $123=$1; + STACKTOP = __stackBase__; + return $123; + default: assert(0, "bad label: " + __label__); + } +} +_ast_binstore_codegen["X"]=1; + +function _ast_unary_new($ctx_0, $ctx_1, $op, $expr) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $self; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$op; + $3=$expr; + var $6=_util_memory_a(64, 427, ((STRING_TABLE.__str)|0)); + var $7=$6; + $self=$7; + var $8=$self; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 9; break; + case 4: + var $12=$self; + var $13=$12; + var $14=(($ctx)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($ctx+4)|0); + var $17=HEAP32[(($16)>>2)]; + _ast_node_init($13, $15, $17, 13); + var $18=$self; + var $19=$18; + var $20=$19; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=(12); + var $22=$self; + var $23=$22; + _ast_expression_init($23, (24)); + var $24=$2; + var $25=$self; + var $26=(($25+56)|0); + HEAP32[(($26)>>2)]=$24; + var $27=$3; + var $28=$self; + var $29=(($28+60)|0); + HEAP32[(($29)>>2)]=$27; + var $30=$2; + var $31=(($30)|0) >= 44; + if ($31) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $33=$2; + var $34=(($33)|0) <= 48; + if ($34) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $36=$self; + var $37=(($36)|0); + var $38=(($37+24)|0); + HEAP32[(($38)>>2)]=2; + __label__ = 8; break; + case 7: + var $40=$2; + var $41=((_asm_instr+($40)*(12))|0); + var $42=(($41)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($ctx)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($ctx+4)|0); + var $47=HEAP32[(($46)>>2)]; + _asterror($45, $47, ((STRING_TABLE.__str1)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$43,tempInt)); + __label__ = 8; break; + case 8: + var $49=$self; + $1=$49; + __label__ = 9; break; + case 9: + var $51=$1; + STACKTOP = __stackBase__; + return $51; + default: assert(0, "bad label: " + __label__); + } +} +_ast_unary_new["X"]=1; + +function _ast_unary_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+60)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+60)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + var $25=$1; + var $26=$25; + _ast_expression_delete($26); + var $27=$1; + var $28=$27; + _util_memory_d($28, 445, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_unary_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $operand=__stackBase__; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((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)); + $1=0; + __label__ = 11; break; + case 4: + var $18=$2; + var $19=(($18)|0); + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $24=$2; + var $25=(($24)|0); + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$5; + HEAP32[(($28)>>2)]=$27; + $1=1; + __label__ = 11; break; + case 6: + var $30=$2; + var $31=(($30+60)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$32; + var $34=(($33+20)|0); + var $35=HEAP32[(($34)>>2)]; + $cgen=$35; + var $36=$cgen; + var $37=$2; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$3; + var $41=FUNCTION_TABLE[$36]($39, $40, 0, $operand); + if ($41) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 11; break; + case 8: + var $44=$3; + var $45=(($44+36)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$3; + var $48=_ast_function_label($47, ((STRING_TABLE.__str18)|0)); + var $49=$2; + var $50=(($49+56)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=HEAP32[(($operand)>>2)]; + var $53=_ir_block_create_unary($46, $48, $51, $52); + var $54=$5; + HEAP32[(($54)>>2)]=$53; + var $55=$5; + var $56=HEAP32[(($55)>>2)]; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 11; break; + case 10: + var $60=$5; + var $61=HEAP32[(($60)>>2)]; + var $62=$2; + var $63=(($62)|0); + var $64=(($63+52)|0); + HEAP32[(($64)>>2)]=$61; + $1=1; + __label__ = 11; break; + case 11: + var $66=$1; + STACKTOP = __stackBase__; + return $66; + default: assert(0, "bad label: " + __label__); + } +} +_ast_unary_codegen["X"]=1; + +function _asterror($ctx_0, $ctx_1, $msg) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $ap=(__stackBase__)+(8); + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + $1=$msg; + var $4=$ap; + HEAP32[(($4)>>2)]=arguments[_asterror.length]; + var $5=$1; + var $6=HEAP32[(($ap)>>2)]; + var $7=(($ctx)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($ctx+4)|0); + var $10=HEAP32[(($9)>>2)]; + _cvprintmsg($8, $10, 2, ((STRING_TABLE.__str108)|0), $5, $6); + var $11=$ap; + ; + STACKTOP = __stackBase__; + return; +} + + +function _ast_return_new($ctx_0, $ctx_1, $expr) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $self; + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $2=$expr; + var $5=_util_memory_a(60, 450, ((STRING_TABLE.__str)|0)); + var $6=$5; + $self=$6; + var $7=$self; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $11=$self; + var $12=$11; + var $13=(($ctx)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($ctx+4)|0); + var $16=HEAP32[(($15)>>2)]; + _ast_node_init($12, $14, $16, 14); + var $17=$self; + var $18=$17; + var $19=$18; + var $20=(($19+8)|0); + HEAP32[(($20)>>2)]=(10); + var $21=$self; + var $22=$21; + _ast_expression_init($22, (2)); + var $23=$2; + var $24=$self; + var $25=(($24+56)|0); + HEAP32[(($25)>>2)]=$23; + var $26=$self; + $1=$26; + __label__ = 5; break; + case 5: + var $28=$1; + STACKTOP = __stackBase__; + return $28; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_return_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + var $2=$1; + var $3=(($2+56)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 8; break; } + case 3: + __label__ = 4; break; + case 4: + var $8=$1; + var $9=(($8+56)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=$10; + var $12=$11; + var $13=(($12+16)|0); + var $14=HEAP8[($13)]; + var $15=(($14) & 1); + if ($15) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $17=$1; + var $18=(($17+56)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$19; + var $21=$20; + var $22=(($21+8)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$1; + var $25=(($24+56)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$26; + FUNCTION_TABLE[$23]($27); + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + var $31=$1; + var $32=$31; + _ast_expression_delete($32); + var $33=$1; + var $34=$33; + _util_memory_d($34, 463, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_return_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $operand=__stackBase__; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((STRING_TABLE.__str19)|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)); + $1=0; + __label__ = 16; break; + case 4: + var $18=$2; + var $19=(($18)|0); + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $24=$2; + var $25=$24; + var $26=(($25)|0); + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($26+4)|0); + var $30=HEAP32[(($29)>>2)]; + _asterror($28, $30, ((STRING_TABLE.__str20)|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)); + $1=0; + __label__ = 16; break; + case 6: + var $32=$2; + var $33=(($32)|0); + var $34=(($33+52)|0); + HEAP32[(($34)>>2)]=1; + var $35=$2; + var $36=(($35+56)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)|0)!=0; + if ($38) { __label__ = 7; break; } else { __label__ = 12; break; } + case 7: + var $40=$2; + var $41=(($40+56)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$42; + var $44=(($43+20)|0); + var $45=HEAP32[(($44)>>2)]; + $cgen=$45; + var $46=$cgen; + var $47=$2; + var $48=(($47+56)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=$3; + var $51=FUNCTION_TABLE[$46]($49, $50, 0, $operand); + if ($51) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 16; break; + case 9: + var $54=$3; + var $55=(($54+36)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=HEAP32[(($operand)>>2)]; + var $58=_ir_block_create_return($56, $57); + if ($58) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 16; break; + case 11: + __label__ = 15; break; + case 12: + var $62=$3; + var $63=(($62+36)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=_ir_block_create_return($64, 0); + if ($65) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + $1=0; + __label__ = 16; break; + case 14: + __label__ = 15; break; + case 15: + $1=1; + __label__ = 16; break; + case 16: + var $70=$1; + STACKTOP = __stackBase__; + return $70; + default: assert(0, "bad label: " + __label__); + } +} +_ast_return_codegen["X"]=1; + +function _ast_entfield_new($ctx_0, $ctx_1, $entity, $field) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $outtype; + var $self; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$entity; + $3=$field; + var $6=_util_memory_a(64, 470, ((STRING_TABLE.__str)|0)); + var $7=$6; + $self=$7; + var $8=$self; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 11; break; + case 4: + var $12=$self; + var $13=$12; + var $14=(($ctx)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($ctx+4)|0); + var $17=HEAP32[(($16)>>2)]; + _ast_node_init($13, $15, $17, 8); + var $18=$self; + var $19=$18; + var $20=$19; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=(46); + var $22=$3; + var $23=$22; + var $24=(($23+24)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)!=5; + if ($26) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $28=$self; + var $29=$28; + _util_memory_d($29, 473, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 11; break; + case 6: + var $31=$3; + var $32=$31; + var $33=(($32+28)|0); + var $34=HEAP32[(($33)>>2)]; + $outtype=$34; + var $35=$outtype; + var $36=(($35)|0)!=0; + if ($36) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $38=$self; + var $39=$38; + _util_memory_d($39, 479, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 11; break; + case 8: + var $41=$self; + var $42=$41; + _ast_expression_init($42, (20)); + var $43=$2; + var $44=$self; + var $45=(($44+56)|0); + HEAP32[(($45)>>2)]=$43; + var $46=$3; + var $47=$self; + var $48=(($47+60)|0); + HEAP32[(($48)>>2)]=$46; + var $49=$self; + var $50=$49; + var $51=$outtype; + var $52=_ast_type_adopt_impl($50, $51); + if ($52) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $54=$self; + _ast_entfield_delete($54); + $1=0; + __label__ = 11; break; + case 10: + var $56=$self; + $1=$56; + __label__ = 11; break; + case 11: + var $58=$1; + STACKTOP = __stackBase__; + return $58; + default: assert(0, "bad label: " + __label__); + } +} +_ast_entfield_new["X"]=1; + +function _ast_entfield_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+56)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+56)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+56)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + var $26=$1; + var $27=(($26+60)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$28; + var $30=$29; + var $31=(($30+16)|0); + var $32=HEAP8[($31)]; + var $33=(($32) & 1); + if ($33) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $35=$1; + var $36=(($35+60)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=$38; + var $40=(($39+8)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$1; + var $43=(($42+60)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$44; + FUNCTION_TABLE[$41]($45); + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $48=$1; + var $49=$48; + _ast_expression_delete($49); + var $50=$1; + var $51=$50; + _util_memory_d($51, 502, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_entfield_delete["X"]=1; + +function _ast_entfield_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $ent=__stackBase__; + var $field=(__stackBase__)+(4); + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $10=$2; + var $11=(($10)|0); + var $12=(($11+48)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $16=$2; + var $17=(($16)|0); + var $18=(($17+48)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$5; + HEAP32[(($20)>>2)]=$19; + $1=1; + __label__ = 21; break; + case 5: + var $22=$4; + var $23=(($22) & 1); + if ($23) { __label__ = 8; break; } else { __label__ = 6; break; } + case 6: + var $25=$2; + var $26=(($25)|0); + var $27=(($26+52)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $31=$2; + var $32=(($31)|0); + var $33=(($32+52)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$5; + HEAP32[(($35)>>2)]=$34; + $1=1; + __label__ = 21; break; + case 8: + var $37=$2; + var $38=(($37+56)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + $cgen=$42; + var $43=$cgen; + var $44=$2; + var $45=(($44+56)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$3; + var $48=FUNCTION_TABLE[$43]($46, $47, 0, $ent); + if ($48) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 21; break; + case 10: + var $51=$2; + var $52=(($51+60)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=$53; + var $55=(($54+20)|0); + var $56=HEAP32[(($55)>>2)]; + $cgen=$56; + var $57=$cgen; + var $58=$2; + var $59=(($58+60)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=$3; + var $62=FUNCTION_TABLE[$57]($60, $61, 0, $field); + if ($62) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 21; break; + case 12: + var $65=$4; + var $66=(($65) & 1); + if ($66) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $68=$3; + var $69=(($68+36)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$3; + var $72=_ast_function_label($71, ((STRING_TABLE.__str21)|0)); + var $73=HEAP32[(($ent)>>2)]; + var $74=HEAP32[(($field)>>2)]; + var $75=_ir_block_create_fieldaddress($70, $72, $73, $74); + var $76=$5; + HEAP32[(($76)>>2)]=$75; + __label__ = 15; break; + case 14: + var $78=$3; + var $79=(($78+36)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=$3; + var $82=_ast_function_label($81, ((STRING_TABLE.__str22)|0)); + var $83=HEAP32[(($ent)>>2)]; + var $84=HEAP32[(($field)>>2)]; + var $85=$2; + var $86=(($85)|0); + var $87=(($86+24)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=_ir_block_create_load_from_ent($80, $82, $83, $84, $88); + var $90=$5; + HEAP32[(($90)>>2)]=$89; + __label__ = 15; break; + case 15: + var $92=$5; + var $93=HEAP32[(($92)>>2)]; + var $94=(($93)|0)!=0; + if ($94) { __label__ = 17; break; } else { __label__ = 16; break; } + case 16: + var $96=$2; + var $97=$96; + var $98=(($97)|0); + var $99=$4; + var $100=(($99) & 1); + var $101=$100 ? (((STRING_TABLE.__str24)|0)) : (((STRING_TABLE.__str25)|0)); + var $102=$2; + var $103=(($102)|0); + var $104=(($103+24)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=((_type_name+($105<<2))|0); + var $107=HEAP32[(($106)>>2)]; + var $108=(($98)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=(($98+4)|0); + var $111=HEAP32[(($110)>>2)]; + _asterror($109, $111, ((STRING_TABLE.__str23)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$101,HEAP32[(((tempInt)+(4))>>2)]=$107,tempInt)); + $1=0; + __label__ = 21; break; + case 17: + var $113=$4; + var $114=(($113) & 1); + if ($114) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + var $116=$5; + var $117=HEAP32[(($116)>>2)]; + var $118=$2; + var $119=(($118)|0); + var $120=(($119+48)|0); + HEAP32[(($120)>>2)]=$117; + __label__ = 20; break; + case 19: + var $122=$5; + var $123=HEAP32[(($122)>>2)]; + var $124=$2; + var $125=(($124)|0); + var $126=(($125+52)|0); + HEAP32[(($126)>>2)]=$123; + __label__ = 20; break; + case 20: + $1=1; + __label__ = 21; break; + case 21: + var $129=$1; + STACKTOP = __stackBase__; + return $129; + default: assert(0, "bad label: " + __label__); + } +} +_ast_entfield_codegen["X"]=1; + +function _ast_member_new($ctx_0, $ctx_1, $owner, $field) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $self; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$owner; + $3=$field; + var $6=_util_memory_a(64, 507, ((STRING_TABLE.__str)|0)); + var $7=$6; + $self=$7; + var $8=$self; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 13; break; + case 4: + var $12=$self; + var $13=$12; + var $14=(($ctx)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($ctx+4)|0); + var $17=HEAP32[(($16)>>2)]; + _ast_node_init($13, $15, $17, 15); + var $18=$self; + var $19=$18; + var $20=$19; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=(38); + var $22=$3; + var $23=(($22)>>>0) >= 3; + if ($23) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $25=$self; + var $26=$25; + _util_memory_d($26, 509, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 13; break; + case 6: + var $28=$2; + var $29=$28; + var $30=(($29+24)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31)|0)!=3; + if ($32) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $34=$2; + var $35=$34; + var $36=(($35+24)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)|0)!=5; + if ($38) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $40=$2; + var $41=$40; + var $42=(($41+24)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((_type_name+($43<<2))|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($ctx)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($ctx+4)|0); + var $49=HEAP32[(($48)>>2)]; + _asterror($47, $49, ((STRING_TABLE.__str2)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$45,tempInt)); + var $50=$self; + var $51=$50; + _util_memory_d($51, 516, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 13; break; + case 9: + var $53=$self; + var $54=$53; + _ast_expression_init($54, (14)); + var $55=$self; + var $56=(($55)|0); + var $57=(($56)|0); + var $58=(($57+16)|0); + HEAP8[($58)]=1; + var $59=$2; + var $60=$59; + var $61=(($60+24)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)==3; + if ($63) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $65=$self; + var $66=(($65)|0); + var $67=(($66+24)|0); + HEAP32[(($67)>>2)]=2; + var $68=$self; + var $69=(($68)|0); + var $70=(($69+28)|0); + HEAP32[(($70)>>2)]=0; + __label__ = 12; break; + case 11: + var $72=$self; + var $73=(($72)|0); + var $74=(($73+24)|0); + HEAP32[(($74)>>2)]=5; + var $75=(($ctx)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($ctx+4)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=_ast_shallow_type($76, $78, 2); + var $80=$self; + var $81=(($80)|0); + var $82=(($81+28)|0); + HEAP32[(($82)>>2)]=$79; + __label__ = 12; break; + case 12: + var $84=$2; + var $85=$self; + var $86=(($85+56)|0); + HEAP32[(($86)>>2)]=$84; + var $87=$3; + var $88=$self; + var $89=(($88+60)|0); + HEAP32[(($89)>>2)]=$87; + var $90=$self; + $1=$90; + __label__ = 13; break; + case 13: + var $92=$1; + STACKTOP = __stackBase__; + return $92; + default: assert(0, "bad label: " + __label__); + } +} +_ast_member_new["X"]=1; + +function _ast_member_delete($self) { + ; + var __label__; + + var $1; + $1=$self; + var $2=$1; + var $3=$2; + _ast_expression_delete($3); + var $4=$1; + var $5=$4; + _util_memory_d($5, 548, ((STRING_TABLE.__str)|0)); + ; + return; +} + + +function _ast_member_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $vec=__stackBase__; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + var $9=$2; + var $10=(($9)|0); + var $11=(($10+48)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$2; + var $16=(($15)|0); + var $17=(($16+48)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$5; + HEAP32[(($19)>>2)]=$18; + $1=1; + __label__ = 11; break; + case 4: + var $21=$2; + var $22=(($21+56)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$23; + var $25=(($24+20)|0); + var $26=HEAP32[(($25)>>2)]; + $cgen=$26; + var $27=$cgen; + var $28=$2; + var $29=(($28+56)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=$3; + var $32=FUNCTION_TABLE[$27]($30, $31, 1, $vec); + if ($32) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 11; break; + case 6: + var $35=HEAP32[(($vec)>>2)]; + var $36=(($35+4)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)|0)!=3; + if ($38) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $40=HEAP32[(($vec)>>2)]; + var $41=(($40+4)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=(($42)|0)==5; + if ($43) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $45=$2; + var $46=(($45+56)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + var $49=(($48+28)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=$50; + var $52=(($51+24)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($53)|0)==3; + if ($54) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 11; break; + case 10: + var $57=HEAP32[(($vec)>>2)]; + var $58=$2; + var $59=(($58+60)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=_ir_value_vector_member($57, $60); + var $62=$5; + HEAP32[(($62)>>2)]=$61; + var $63=$5; + var $64=HEAP32[(($63)>>2)]; + var $65=$2; + var $66=(($65)|0); + var $67=(($66+48)|0); + HEAP32[(($67)>>2)]=$64; + var $68=$5; + var $69=HEAP32[(($68)>>2)]; + var $70=(($69)|0)!=0; + $1=$70; + __label__ = 11; break; + case 11: + var $72=$1; + STACKTOP = __stackBase__; + return $72; + default: assert(0, "bad label: " + __label__); + } +} +_ast_member_codegen["X"]=1; + +function _ast_shallow_type($ctx_0, $ctx_1, $vtype) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $self; + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $2=$vtype; + var $5=_util_memory_a(92, 145, ((STRING_TABLE.__str)|0)); + var $6=$5; + $self=$6; + var $7=$self; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $11=$self; + var $12=$11; + var $13=(($ctx)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($ctx+4)|0); + var $16=HEAP32[(($15)>>2)]; + _ast_node_init($12, $14, $16, 1); + var $17=$self; + var $18=$17; + var $19=$18; + var $20=(($19+8)|0); + HEAP32[(($20)>>2)]=(22); + var $21=$self; + _ast_expression_init($21, 0); + var $22=$self; + var $23=$22; + var $24=(($23+20)|0); + HEAP32[(($24)>>2)]=0; + var $25=$self; + var $26=$25; + var $27=(($26+28)|0); + HEAP32[(($27)>>2)]=0; + var $28=$2; + var $29=$self; + var $30=$29; + var $31=(($30+24)|0); + HEAP32[(($31)>>2)]=$28; + var $32=$self; + $1=$32; + __label__ = 5; break; + case 5: + var $34=$1; + STACKTOP = __stackBase__; + return $34; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_ifthen_new($ctx_0, $ctx_1, $cond, $ontrue, $onfalse) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $4; + var $self; + var $5=(($ctx)|0); + HEAP32[(($5)>>2)]=$ctx_0; + var $6=(($ctx+4)|0); + HEAP32[(($6)>>2)]=$ctx_1; + $2=$cond; + $3=$ontrue; + $4=$onfalse; + var $7=_util_memory_a(68, 553, ((STRING_TABLE.__str)|0)); + var $8=$7; + $self=$8; + var $9=$self; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 8; break; + case 4: + var $13=$self; + var $14=$13; + var $15=(($ctx)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($ctx+4)|0); + var $18=HEAP32[(($17)>>2)]; + _ast_node_init($14, $16, $18, 9); + var $19=$self; + var $20=$19; + var $21=$20; + var $22=(($21+8)|0); + HEAP32[(($22)>>2)]=(18); + var $23=$3; + var $24=(($23)|0)!=0; + if ($24) { __label__ = 7; break; } else { __label__ = 5; break; } + case 5: + var $26=$4; + var $27=(($26)|0)!=0; + if ($27) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $29=$self; + var $30=$29; + _util_memory_d($30, 556, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 8; break; + case 7: + var $32=$self; + var $33=$32; + _ast_expression_init($33, (4)); + var $34=$2; + var $35=$self; + var $36=(($35+56)|0); + HEAP32[(($36)>>2)]=$34; + var $37=$3; + var $38=$self; + var $39=(($38+60)|0); + HEAP32[(($39)>>2)]=$37; + var $40=$4; + var $41=$self; + var $42=(($41+64)|0); + HEAP32[(($42)>>2)]=$40; + var $43=$self; + $1=$43; + __label__ = 8; break; + case 8: + var $45=$1; + STACKTOP = __stackBase__; + return $45; + default: assert(0, "bad label: " + __label__); + } +} +_ast_ifthen_new["X"]=1; + +function _ast_ifthen_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+56)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+56)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+56)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + var $25=$1; + var $26=(($25+60)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27)|0)!=0; + if ($28) { __label__ = 7; break; } else { __label__ = 12; break; } + case 7: + __label__ = 8; break; + case 8: + var $31=$1; + var $32=(($31+60)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=$33; + var $35=$34; + var $36=(($35+16)|0); + var $37=HEAP8[($36)]; + var $38=(($37) & 1); + if ($38) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $40=$1; + var $41=(($40+60)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$42; + var $44=$43; + var $45=(($44+8)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$1; + var $48=(($47+60)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=$49; + FUNCTION_TABLE[$46]($50); + __label__ = 10; break; + case 10: + __label__ = 11; break; + case 11: + __label__ = 12; break; + case 12: + var $54=$1; + var $55=(($54+64)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 13; break; } else { __label__ = 18; break; } + case 13: + __label__ = 14; break; + case 14: + var $60=$1; + var $61=(($60+64)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=$62; + var $64=$63; + var $65=(($64+16)|0); + var $66=HEAP8[($65)]; + var $67=(($66) & 1); + if ($67) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $69=$1; + var $70=(($69+64)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$71; + var $73=$72; + var $74=(($73+8)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$1; + var $77=(($76+64)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$78; + FUNCTION_TABLE[$75]($79); + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + __label__ = 18; break; + case 18: + var $83=$1; + var $84=$83; + _ast_expression_delete($84); + var $85=$1; + var $86=$85; + _util_memory_d($86, 576, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_ifthen_delete["X"]=1; + +function _ast_ifthen_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $condval=__stackBase__; + var $dummy=(__stackBase__)+(4); + var $cond; + var $ontrue; + var $onfalse; + var $ontrue_endblock; + var $onfalse_endblock; + var $merge; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$3; + var $8=(($7+36)|0); + var $9=HEAP32[(($8)>>2)]; + $cond=$9; + $ontrue_endblock=0; + $onfalse_endblock=0; + var $10=$5; + var $11=$4; + var $12=(($11) & 1); + var $13=$2; + var $14=(($13)|0); + var $15=(($14+52)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $19=$2; + var $20=$19; + var $21=(($20)|0); + var $22=(($21)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($21+4)|0); + var $25=HEAP32[(($24)>>2)]; + _asterror($23, $25, ((STRING_TABLE.__str26)|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)); + $1=0; + __label__ = 39; break; + case 4: + var $27=$2; + var $28=(($27)|0); + var $29=(($28+52)|0); + HEAP32[(($29)>>2)]=1; + var $30=$cond; + var $31=$3; + var $32=(($31+36)|0); + HEAP32[(($32)>>2)]=$30; + var $33=$2; + var $34=(($33+56)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$35; + var $37=(($36+20)|0); + var $38=HEAP32[(($37)>>2)]; + $cgen=$38; + var $39=$cgen; + var $40=$2; + var $41=(($40+56)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$3; + var $44=FUNCTION_TABLE[$39]($42, $43, 0, $condval); + if ($44) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 39; break; + case 6: + var $47=$2; + var $48=(($47+60)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($49)|0)!=0; + if ($50) { __label__ = 7; break; } else { __label__ = 12; break; } + case 7: + var $52=$3; + var $53=(($52+32)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=$3; + var $56=_ast_function_label($55, ((STRING_TABLE.__str27)|0)); + var $57=_ir_function_create_block($54, $56); + $ontrue=$57; + var $58=$ontrue; + var $59=(($58)|0)!=0; + if ($59) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 39; break; + case 9: + var $62=$ontrue; + var $63=$3; + var $64=(($63+36)|0); + HEAP32[(($64)>>2)]=$62; + var $65=$2; + var $66=(($65+60)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=(($68+20)|0); + var $70=HEAP32[(($69)>>2)]; + $cgen=$70; + var $71=$cgen; + var $72=$2; + var $73=(($72+60)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=$3; + var $76=FUNCTION_TABLE[$71]($74, $75, 0, $dummy); + if ($76) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 39; break; + case 11: + var $79=$3; + var $80=(($79+36)|0); + var $81=HEAP32[(($80)>>2)]; + $ontrue_endblock=$81; + __label__ = 13; break; + case 12: + $ontrue=0; + __label__ = 13; break; + case 13: + var $84=$2; + var $85=(($84+64)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=(($86)|0)!=0; + if ($87) { __label__ = 14; break; } else { __label__ = 19; break; } + case 14: + var $89=$3; + var $90=(($89+32)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=$3; + var $93=_ast_function_label($92, ((STRING_TABLE.__str28)|0)); + var $94=_ir_function_create_block($91, $93); + $onfalse=$94; + var $95=$onfalse; + var $96=(($95)|0)!=0; + if ($96) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 39; break; + case 16: + var $99=$onfalse; + var $100=$3; + var $101=(($100+36)|0); + HEAP32[(($101)>>2)]=$99; + var $102=$2; + var $103=(($102+64)|0); + var $104=HEAP32[(($103)>>2)]; + var $105=$104; + var $106=(($105+20)|0); + var $107=HEAP32[(($106)>>2)]; + $cgen=$107; + var $108=$cgen; + var $109=$2; + var $110=(($109+64)|0); + var $111=HEAP32[(($110)>>2)]; + var $112=$3; + var $113=FUNCTION_TABLE[$108]($111, $112, 0, $dummy); + if ($113) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 39; break; + case 18: + var $116=$3; + var $117=(($116+36)|0); + var $118=HEAP32[(($117)>>2)]; + $onfalse_endblock=$118; + __label__ = 20; break; + case 19: + $onfalse=0; + __label__ = 20; break; + case 20: + var $121=$3; + var $122=(($121+32)|0); + var $123=HEAP32[(($122)>>2)]; + var $124=$3; + var $125=_ast_function_label($124, ((STRING_TABLE.__str29)|0)); + var $126=_ir_function_create_block($123, $125); + $merge=$126; + var $127=$merge; + var $128=(($127)|0)!=0; + if ($128) { __label__ = 22; break; } else { __label__ = 21; break; } + case 21: + $1=0; + __label__ = 39; break; + case 22: + var $131=$ontrue; + var $132=(($131)|0)!=0; + if ($132) { __label__ = 23; break; } else { __label__ = 26; break; } + case 23: + var $134=$ontrue_endblock; + var $135=(($134+12)|0); + var $136=HEAP8[($135)]; + var $137=(($136) & 1); + if ($137) { __label__ = 26; break; } else { __label__ = 24; break; } + case 24: + var $139=$ontrue_endblock; + var $140=$merge; + var $141=_ir_block_create_jump($139, $140); + if ($141) { __label__ = 26; break; } else { __label__ = 25; break; } + case 25: + $1=0; + __label__ = 39; break; + case 26: + var $144=$onfalse; + var $145=(($144)|0)!=0; + if ($145) { __label__ = 27; break; } else { __label__ = 30; break; } + case 27: + var $147=$onfalse_endblock; + var $148=(($147+12)|0); + var $149=HEAP8[($148)]; + var $150=(($149) & 1); + if ($150) { __label__ = 30; break; } else { __label__ = 28; break; } + case 28: + var $152=$onfalse_endblock; + var $153=$merge; + var $154=_ir_block_create_jump($152, $153); + if ($154) { __label__ = 30; break; } else { __label__ = 29; break; } + case 29: + $1=0; + __label__ = 39; break; + case 30: + var $157=$cond; + var $158=HEAP32[(($condval)>>2)]; + var $159=$ontrue; + var $160=(($159)|0)!=0; + if ($160) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + var $162=$ontrue; + var $166 = $162;__label__ = 33; break; + case 32: + var $164=$merge; + var $166 = $164;__label__ = 33; break; + case 33: + var $166; + var $167=$onfalse; + var $168=(($167)|0)!=0; + if ($168) { __label__ = 34; break; } else { __label__ = 35; break; } + case 34: + var $170=$onfalse; + var $174 = $170;__label__ = 36; break; + case 35: + var $172=$merge; + var $174 = $172;__label__ = 36; break; + case 36: + var $174; + var $175=_ir_block_create_if($157, $158, $166, $174); + if ($175) { __label__ = 38; break; } else { __label__ = 37; break; } + case 37: + $1=0; + __label__ = 39; break; + case 38: + var $178=$merge; + var $179=$3; + var $180=(($179+36)|0); + HEAP32[(($180)>>2)]=$178; + $1=1; + __label__ = 39; break; + case 39: + var $182=$1; + STACKTOP = __stackBase__; + return $182; + default: assert(0, "bad label: " + __label__); + } +} +_ast_ifthen_codegen["X"]=1; + +function _ast_loop_new($ctx_0, $ctx_1, $initexpr, $precond, $postcond, $increment, $body) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $4; + var $5; + var $6; + var $self; + var $7=(($ctx)|0); + HEAP32[(($7)>>2)]=$ctx_0; + var $8=(($ctx+4)|0); + HEAP32[(($8)>>2)]=$ctx_1; + $2=$initexpr; + $3=$precond; + $4=$postcond; + $5=$increment; + $6=$body; + var $9=_util_memory_a(76, 613, ((STRING_TABLE.__str)|0)); + var $10=$9; + $self=$10; + var $11=$self; + var $12=(($11)|0)!=0; + if ($12) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $15=$self; + var $16=$15; + var $17=(($ctx)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($ctx+4)|0); + var $20=HEAP32[(($19)>>2)]; + _ast_node_init($16, $18, $20, 11); + var $21=$self; + var $22=$21; + var $23=$22; + var $24=(($23+8)|0); + HEAP32[(($24)>>2)]=(28); + var $25=$self; + var $26=$25; + _ast_expression_init($26, (50)); + var $27=$2; + var $28=$self; + var $29=(($28+56)|0); + HEAP32[(($29)>>2)]=$27; + var $30=$3; + var $31=$self; + var $32=(($31+60)|0); + HEAP32[(($32)>>2)]=$30; + var $33=$4; + var $34=$self; + var $35=(($34+64)|0); + HEAP32[(($35)>>2)]=$33; + var $36=$5; + var $37=$self; + var $38=(($37+68)|0); + HEAP32[(($38)>>2)]=$36; + var $39=$6; + var $40=$self; + var $41=(($40+72)|0); + HEAP32[(($41)>>2)]=$39; + var $42=$self; + $1=$42; + __label__ = 5; break; + case 5: + var $44=$1; + STACKTOP = __stackBase__; + return $44; + default: assert(0, "bad label: " + __label__); + } +} +_ast_loop_new["X"]=1; + +function _ast_loop_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + var $2=$1; + var $3=(($2+56)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 8; break; } + case 3: + __label__ = 4; break; + case 4: + var $8=$1; + var $9=(($8+56)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=$10; + var $12=$11; + var $13=(($12+16)|0); + var $14=HEAP8[($13)]; + var $15=(($14) & 1); + if ($15) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $17=$1; + var $18=(($17+56)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$19; + var $21=$20; + var $22=(($21+8)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$1; + var $25=(($24+56)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$26; + FUNCTION_TABLE[$23]($27); + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + var $31=$1; + var $32=(($31+60)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33)|0)!=0; + if ($34) { __label__ = 9; break; } else { __label__ = 14; break; } + case 9: + __label__ = 10; break; + case 10: + var $37=$1; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$40; + var $42=(($41+16)|0); + var $43=HEAP8[($42)]; + var $44=(($43) & 1); + if ($44) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $46=$1; + var $47=(($46+60)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + var $50=$49; + var $51=(($50+8)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=$1; + var $54=(($53+60)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$55; + FUNCTION_TABLE[$52]($56); + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $60=$1; + var $61=(($60+64)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)!=0; + if ($63) { __label__ = 15; break; } else { __label__ = 20; break; } + case 15: + __label__ = 16; break; + case 16: + var $66=$1; + var $67=(($66+64)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$69; + var $71=(($70+16)|0); + var $72=HEAP8[($71)]; + var $73=(($72) & 1); + if ($73) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $75=$1; + var $76=(($75+64)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=$77; + var $79=$78; + var $80=(($79+8)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=$1; + var $83=(($82+64)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=$84; + FUNCTION_TABLE[$81]($85); + __label__ = 18; break; + case 18: + __label__ = 19; break; + case 19: + __label__ = 20; break; + case 20: + var $89=$1; + var $90=(($89+68)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($91)|0)!=0; + if ($92) { __label__ = 21; break; } else { __label__ = 26; break; } + case 21: + __label__ = 22; break; + case 22: + var $95=$1; + var $96=(($95+68)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=$97; + var $99=$98; + var $100=(($99+16)|0); + var $101=HEAP8[($100)]; + var $102=(($101) & 1); + if ($102) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $104=$1; + var $105=(($104+68)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=$106; + var $108=$107; + var $109=(($108+8)|0); + var $110=HEAP32[(($109)>>2)]; + var $111=$1; + var $112=(($111+68)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$113; + FUNCTION_TABLE[$110]($114); + __label__ = 24; break; + case 24: + __label__ = 25; break; + case 25: + __label__ = 26; break; + case 26: + var $118=$1; + var $119=(($118+72)|0); + var $120=HEAP32[(($119)>>2)]; + var $121=(($120)|0)!=0; + if ($121) { __label__ = 27; break; } else { __label__ = 32; break; } + case 27: + __label__ = 28; break; + case 28: + var $124=$1; + var $125=(($124+72)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=$126; + var $128=$127; + var $129=(($128+16)|0); + var $130=HEAP8[($129)]; + var $131=(($130) & 1); + if ($131) { __label__ = 30; break; } else { __label__ = 29; break; } + case 29: + var $133=$1; + var $134=(($133+72)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=$135; + var $137=$136; + var $138=(($137+8)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=$1; + var $141=(($140+72)|0); + var $142=HEAP32[(($141)>>2)]; + var $143=$142; + FUNCTION_TABLE[$139]($143); + __label__ = 30; break; + case 30: + __label__ = 31; break; + case 31: + __label__ = 32; break; + case 32: + var $147=$1; + var $148=$147; + _ast_expression_delete($148); + var $149=$1; + var $150=$149; + _util_memory_d($150, 638, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_loop_delete["X"]=1; + +function _ast_loop_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $dummy=__stackBase__; + var $precond=(__stackBase__)+(4); + var $postcond=(__stackBase__)+(8); + var $bbody; + var $end_bbody; + var $bprecond; + var $end_bprecond; + var $bpostcond; + var $end_bpostcond; + var $bincrement; + var $end_bincrement; + var $bout; + var $bin; + var $bout_id; + var $bcontinue; + var $bbreak; + var $old_bcontinue; + var $old_bbreak; + var $tmpblock; + var $ontrue; + var $onfalse; + var $ontrue1; + var $onfalse2; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + HEAP32[(($dummy)>>2)]=0; + HEAP32[(($precond)>>2)]=0; + HEAP32[(($postcond)>>2)]=0; + $bbody=0; + $end_bbody=0; + $bprecond=0; + $end_bprecond=0; + $bpostcond=0; + $end_bpostcond=0; + $bincrement=0; + $end_bincrement=0; + $bout=0; + $bin=0; + $bcontinue=0; + $bbreak=0; + $old_bcontinue=0; + $old_bbreak=0; + $tmpblock=0; + var $7=$4; + var $8=(($7) & 1); + var $9=$5; + var $10=$2; + var $11=(($10)|0); + var $12=(($11+52)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $16=$2; + var $17=$16; + var $18=(($17)|0); + var $19=(($18)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($18+4)|0); + var $22=HEAP32[(($21)>>2)]; + _asterror($20, $22, ((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)); + $1=0; + __label__ = 109; break; + case 4: + var $24=$2; + var $25=(($24)|0); + var $26=(($25+52)|0); + HEAP32[(($26)>>2)]=1; + var $27=$2; + var $28=(($27+56)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $32=$2; + var $33=(($32+56)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$34; + var $36=(($35+20)|0); + var $37=HEAP32[(($36)>>2)]; + $cgen=$37; + var $38=$cgen; + var $39=$2; + var $40=(($39+56)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$3; + var $43=FUNCTION_TABLE[$38]($41, $42, 0, $dummy); + if ($43) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + $1=0; + __label__ = 109; break; + case 7: + __label__ = 8; break; + case 8: + var $47=$3; + var $48=(($47+36)|0); + var $49=HEAP32[(($48)>>2)]; + $bin=$49; + var $50=$2; + var $51=(($50+60)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($52)|0)!=0; + if ($53) { __label__ = 9; break; } else { __label__ = 14; break; } + case 9: + var $55=$3; + var $56=(($55+32)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$3; + var $59=_ast_function_label($58, ((STRING_TABLE.__str35)|0)); + var $60=_ir_function_create_block($57, $59); + $bprecond=$60; + var $61=$bprecond; + var $62=(($61)|0)!=0; + if ($62) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 109; break; + case 11: + var $65=$bprecond; + $bcontinue=$65; + var $66=$bprecond; + var $67=$3; + var $68=(($67+36)|0); + HEAP32[(($68)>>2)]=$66; + var $69=$2; + var $70=(($69+60)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$71; + var $73=(($72+20)|0); + var $74=HEAP32[(($73)>>2)]; + $cgen=$74; + var $75=$cgen; + var $76=$2; + var $77=(($76+60)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$3; + var $80=FUNCTION_TABLE[$75]($78, $79, 0, $precond); + if ($80) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + $1=0; + __label__ = 109; break; + case 13: + var $83=$3; + var $84=(($83+36)|0); + var $85=HEAP32[(($84)>>2)]; + $end_bprecond=$85; + __label__ = 15; break; + case 14: + $end_bprecond=0; + $bprecond=0; + __label__ = 15; break; + case 15: + var $88=$2; + var $89=(($88+68)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=(($90)|0)!=0; + if ($91) { __label__ = 16; break; } else { __label__ = 19; break; } + case 16: + var $93=$3; + var $94=(($93+32)|0); + var $95=HEAP32[(($94)>>2)]; + var $96=$3; + var $97=_ast_function_label($96, ((STRING_TABLE.__str36)|0)); + var $98=_ir_function_create_block($95, $97); + $bincrement=$98; + var $99=$bincrement; + var $100=(($99)|0)!=0; + if ($100) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 109; break; + case 18: + var $103=$bincrement; + $bcontinue=$103; + __label__ = 20; break; + case 19: + $end_bincrement=0; + $bincrement=0; + __label__ = 20; break; + case 20: + var $106=$2; + var $107=(($106+64)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108)|0)!=0; + if ($109) { __label__ = 21; break; } else { __label__ = 24; break; } + case 21: + var $111=$3; + var $112=(($111+32)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$3; + var $115=_ast_function_label($114, ((STRING_TABLE.__str37)|0)); + var $116=_ir_function_create_block($113, $115); + $bpostcond=$116; + var $117=$bpostcond; + var $118=(($117)|0)!=0; + if ($118) { __label__ = 23; break; } else { __label__ = 22; break; } + case 22: + $1=0; + __label__ = 109; break; + case 23: + var $121=$bpostcond; + $bcontinue=$121; + __label__ = 25; break; + case 24: + $end_bpostcond=0; + $bpostcond=0; + __label__ = 25; break; + case 25: + var $124=$3; + var $125=(($124+32)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=(($126+24)|0); + var $128=HEAP32[(($127)>>2)]; + $bout_id=$128; + var $129=$3; + var $130=(($129+32)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=$3; + var $133=_ast_function_label($132, ((STRING_TABLE.__str38)|0)); + var $134=_ir_function_create_block($131, $133); + $bout=$134; + var $135=$bout; + var $136=(($135)|0)!=0; + if ($136) { __label__ = 27; break; } else { __label__ = 26; break; } + case 26: + $1=0; + __label__ = 109; break; + case 27: + var $139=$bout; + $bbreak=$139; + var $140=$2; + var $141=(($140+72)|0); + var $142=HEAP32[(($141)>>2)]; + var $143=(($142)|0)!=0; + if ($143) { __label__ = 28; break; } else { __label__ = 33; break; } + case 28: + var $145=$3; + var $146=(($145+32)|0); + var $147=HEAP32[(($146)>>2)]; + var $148=$3; + var $149=_ast_function_label($148, ((STRING_TABLE.__str39)|0)); + var $150=_ir_function_create_block($147, $149); + $bbody=$150; + var $151=$bbody; + var $152=(($151)|0)!=0; + if ($152) { __label__ = 30; break; } else { __label__ = 29; break; } + case 29: + $1=0; + __label__ = 109; break; + case 30: + var $155=$bbody; + var $156=$3; + var $157=(($156+36)|0); + HEAP32[(($157)>>2)]=$155; + var $158=$3; + var $159=(($158+40)|0); + var $160=HEAP32[(($159)>>2)]; + $old_bbreak=$160; + var $161=$3; + var $162=(($161+44)|0); + var $163=HEAP32[(($162)>>2)]; + $old_bcontinue=$163; + var $164=$bbreak; + var $165=$3; + var $166=(($165+40)|0); + HEAP32[(($166)>>2)]=$164; + var $167=$bcontinue; + var $168=$3; + var $169=(($168+44)|0); + HEAP32[(($169)>>2)]=$167; + var $170=$2; + var $171=(($170+72)|0); + var $172=HEAP32[(($171)>>2)]; + var $173=$172; + var $174=(($173+20)|0); + var $175=HEAP32[(($174)>>2)]; + $cgen=$175; + var $176=$cgen; + var $177=$2; + var $178=(($177+72)|0); + var $179=HEAP32[(($178)>>2)]; + var $180=$3; + var $181=FUNCTION_TABLE[$176]($179, $180, 0, $dummy); + if ($181) { __label__ = 32; break; } else { __label__ = 31; break; } + case 31: + $1=0; + __label__ = 109; break; + case 32: + var $184=$3; + var $185=(($184+36)|0); + var $186=HEAP32[(($185)>>2)]; + $end_bbody=$186; + var $187=$old_bbreak; + var $188=$3; + var $189=(($188+40)|0); + HEAP32[(($189)>>2)]=$187; + var $190=$old_bcontinue; + var $191=$3; + var $192=(($191+44)|0); + HEAP32[(($192)>>2)]=$190; + __label__ = 33; break; + case 33: + var $194=$2; + var $195=(($194+64)|0); + var $196=HEAP32[(($195)>>2)]; + var $197=(($196)|0)!=0; + if ($197) { __label__ = 34; break; } else { __label__ = 37; break; } + case 34: + var $199=$bpostcond; + var $200=$3; + var $201=(($200+36)|0); + HEAP32[(($201)>>2)]=$199; + var $202=$2; + var $203=(($202+64)|0); + var $204=HEAP32[(($203)>>2)]; + var $205=$204; + var $206=(($205+20)|0); + var $207=HEAP32[(($206)>>2)]; + $cgen=$207; + var $208=$cgen; + var $209=$2; + var $210=(($209+64)|0); + var $211=HEAP32[(($210)>>2)]; + var $212=$3; + var $213=FUNCTION_TABLE[$208]($211, $212, 0, $postcond); + if ($213) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + $1=0; + __label__ = 109; break; + case 36: + var $216=$3; + var $217=(($216+36)|0); + var $218=HEAP32[(($217)>>2)]; + $end_bpostcond=$218; + __label__ = 37; break; + case 37: + var $220=$2; + var $221=(($220+68)|0); + var $222=HEAP32[(($221)>>2)]; + var $223=(($222)|0)!=0; + if ($223) { __label__ = 38; break; } else { __label__ = 41; break; } + case 38: + var $225=$bincrement; + var $226=$3; + var $227=(($226+36)|0); + HEAP32[(($227)>>2)]=$225; + var $228=$2; + var $229=(($228+68)|0); + var $230=HEAP32[(($229)>>2)]; + var $231=$230; + var $232=(($231+20)|0); + var $233=HEAP32[(($232)>>2)]; + $cgen=$233; + var $234=$cgen; + var $235=$2; + var $236=(($235+68)|0); + var $237=HEAP32[(($236)>>2)]; + var $238=$3; + var $239=FUNCTION_TABLE[$234]($237, $238, 0, $dummy); + if ($239) { __label__ = 40; break; } else { __label__ = 39; break; } + case 39: + $1=0; + __label__ = 109; break; + case 40: + var $242=$3; + var $243=(($242+36)|0); + var $244=HEAP32[(($243)>>2)]; + $end_bincrement=$244; + __label__ = 41; break; + case 41: + var $246=$bout; + var $247=$3; + var $248=(($247+36)|0); + HEAP32[(($248)>>2)]=$246; + var $249=$bprecond; + var $250=(($249)|0)!=0; + if ($250) { __label__ = 42; break; } else { __label__ = 43; break; } + case 42: + var $252=$bprecond; + $tmpblock=$252; + __label__ = 50; break; + case 43: + var $254=$bbody; + var $255=(($254)|0)!=0; + if ($255) { __label__ = 44; break; } else { __label__ = 45; break; } + case 44: + var $257=$bbody; + $tmpblock=$257; + __label__ = 49; break; + case 45: + var $259=$bpostcond; + var $260=(($259)|0)!=0; + if ($260) { __label__ = 46; break; } else { __label__ = 47; break; } + case 46: + var $262=$bpostcond; + $tmpblock=$262; + __label__ = 48; break; + case 47: + var $264=$bout; + $tmpblock=$264; + __label__ = 48; break; + case 48: + __label__ = 49; break; + case 49: + __label__ = 50; break; + case 50: + var $268=$bin; + var $269=$tmpblock; + var $270=_ir_block_create_jump($268, $269); + if ($270) { __label__ = 52; break; } else { __label__ = 51; break; } + case 51: + $1=0; + __label__ = 109; break; + case 52: + var $273=$bprecond; + var $274=(($273)|0)!=0; + if ($274) { __label__ = 53; break; } else { __label__ = 65; break; } + case 53: + var $276=$bbody; + var $277=(($276)|0)!=0; + if ($277) { __label__ = 54; break; } else { __label__ = 55; break; } + case 54: + var $279=$bbody; + $ontrue=$279; + __label__ = 62; break; + case 55: + var $281=$bincrement; + var $282=(($281)|0)!=0; + if ($282) { __label__ = 56; break; } else { __label__ = 57; break; } + case 56: + var $284=$bincrement; + $ontrue=$284; + __label__ = 61; break; + case 57: + var $286=$bpostcond; + var $287=(($286)|0)!=0; + if ($287) { __label__ = 58; break; } else { __label__ = 59; break; } + case 58: + var $289=$bpostcond; + $ontrue=$289; + __label__ = 60; break; + case 59: + var $291=$bprecond; + $ontrue=$291; + __label__ = 60; break; + case 60: + __label__ = 61; break; + case 61: + __label__ = 62; break; + case 62: + var $295=$bout; + $onfalse=$295; + var $296=$end_bprecond; + var $297=HEAP32[(($precond)>>2)]; + var $298=$ontrue; + var $299=$onfalse; + var $300=_ir_block_create_if($296, $297, $298, $299); + if ($300) { __label__ = 64; break; } else { __label__ = 63; break; } + case 63: + $1=0; + __label__ = 109; break; + case 64: + __label__ = 65; break; + case 65: + var $304=$bbody; + var $305=(($304)|0)!=0; + if ($305) { __label__ = 66; break; } else { __label__ = 79; break; } + case 66: + var $307=$bincrement; + var $308=(($307)|0)!=0; + if ($308) { __label__ = 67; break; } else { __label__ = 68; break; } + case 67: + var $310=$bincrement; + $tmpblock=$310; + __label__ = 75; break; + case 68: + var $312=$bpostcond; + var $313=(($312)|0)!=0; + if ($313) { __label__ = 69; break; } else { __label__ = 70; break; } + case 69: + var $315=$bpostcond; + $tmpblock=$315; + __label__ = 74; break; + case 70: + var $317=$bprecond; + var $318=(($317)|0)!=0; + if ($318) { __label__ = 71; break; } else { __label__ = 72; break; } + case 71: + var $320=$bprecond; + $tmpblock=$320; + __label__ = 73; break; + case 72: + var $322=$bout; + $tmpblock=$322; + __label__ = 73; break; + case 73: + __label__ = 74; break; + case 74: + __label__ = 75; break; + case 75: + var $326=$end_bbody; + var $327=(($326+12)|0); + var $328=HEAP8[($327)]; + var $329=(($328) & 1); + if ($329) { __label__ = 78; break; } else { __label__ = 76; break; } + case 76: + var $331=$end_bbody; + var $332=$tmpblock; + var $333=_ir_block_create_jump($331, $332); + if ($333) { __label__ = 78; break; } else { __label__ = 77; break; } + case 77: + $1=0; + __label__ = 109; break; + case 78: + __label__ = 79; break; + case 79: + var $337=$bincrement; + var $338=(($337)|0)!=0; + if ($338) { __label__ = 80; break; } else { __label__ = 92; break; } + case 80: + var $340=$bpostcond; + var $341=(($340)|0)!=0; + if ($341) { __label__ = 81; break; } else { __label__ = 82; break; } + case 81: + var $343=$bpostcond; + $tmpblock=$343; + __label__ = 89; break; + case 82: + var $345=$bprecond; + var $346=(($345)|0)!=0; + if ($346) { __label__ = 83; break; } else { __label__ = 84; break; } + case 83: + var $348=$bprecond; + $tmpblock=$348; + __label__ = 88; break; + case 84: + var $350=$bbody; + var $351=(($350)|0)!=0; + if ($351) { __label__ = 85; break; } else { __label__ = 86; break; } + case 85: + var $353=$bbody; + $tmpblock=$353; + __label__ = 87; break; + case 86: + var $355=$bout; + $tmpblock=$355; + __label__ = 87; break; + case 87: + __label__ = 88; break; + case 88: + __label__ = 89; break; + case 89: + var $359=$end_bincrement; + var $360=$tmpblock; + var $361=_ir_block_create_jump($359, $360); + if ($361) { __label__ = 91; break; } else { __label__ = 90; break; } + case 90: + $1=0; + __label__ = 109; break; + case 91: + __label__ = 92; break; + case 92: + var $365=$bpostcond; + var $366=(($365)|0)!=0; + if ($366) { __label__ = 93; break; } else { __label__ = 105; break; } + case 93: + var $368=$bprecond; + var $369=(($368)|0)!=0; + if ($369) { __label__ = 94; break; } else { __label__ = 95; break; } + case 94: + var $371=$bprecond; + $ontrue1=$371; + __label__ = 102; break; + case 95: + var $373=$bbody; + var $374=(($373)|0)!=0; + if ($374) { __label__ = 96; break; } else { __label__ = 97; break; } + case 96: + var $376=$bbody; + $ontrue1=$376; + __label__ = 101; break; + case 97: + var $378=$bincrement; + var $379=(($378)|0)!=0; + if ($379) { __label__ = 98; break; } else { __label__ = 99; break; } + case 98: + var $381=$bincrement; + $ontrue1=$381; + __label__ = 100; break; + case 99: + var $383=$bpostcond; + $ontrue1=$383; + __label__ = 100; break; + case 100: + __label__ = 101; break; + case 101: + __label__ = 102; break; + case 102: + var $387=$bout; + $onfalse2=$387; + var $388=$end_bpostcond; + var $389=HEAP32[(($postcond)>>2)]; + var $390=$ontrue1; + var $391=$onfalse2; + var $392=_ir_block_create_if($388, $389, $390, $391); + if ($392) { __label__ = 104; break; } else { __label__ = 103; break; } + case 103: + $1=0; + __label__ = 109; break; + case 104: + __label__ = 105; break; + case 105: + var $396=$3; + var $397=(($396+32)|0); + var $398=HEAP32[(($397)>>2)]; + var $399=$bout_id; + var $400=_ir_function_blocks_remove($398, $399); + if ($400) { __label__ = 106; break; } else { __label__ = 107; break; } + case 106: + var $402=$3; + var $403=(($402+32)|0); + var $404=HEAP32[(($403)>>2)]; + var $405=$bout; + var $406=_ir_function_blocks_add($404, $405); + if ($406) { __label__ = 108; break; } else { __label__ = 107; break; } + case 107: + var $408=$bout; + _ir_block_delete($408); + $1=0; + __label__ = 109; break; + case 108: + $1=1; + __label__ = 109; break; + case 109: + var $411=$1; + STACKTOP = __stackBase__; + return $411; + default: assert(0, "bad label: " + __label__); + } +} +_ast_loop_codegen["X"]=1; + +function _ast_call_new($ctx_0, $ctx_1, $funcexpr) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $self; + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $2=$funcexpr; + var $5=_util_memory_a(72, 644, ((STRING_TABLE.__str)|0)); + var $6=$5; + $self=$6; + var $7=$self; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $11=$self; + var $12=$11; + var $13=(($ctx)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($ctx+4)|0); + var $16=HEAP32[(($15)>>2)]; + _ast_node_init($12, $14, $16, 12); + var $17=$self; + var $18=$17; + var $19=$18; + var $20=(($19+8)|0); + HEAP32[(($20)>>2)]=(42); + var $21=$self; + var $22=$21; + _ast_expression_init($22, (52)); + var $23=$self; + var $24=(($23+60)|0); + HEAP32[(($24)>>2)]=0; + var $25=$self; + var $26=(($25+64)|0); + HEAP32[(($26)>>2)]=0; + var $27=$self; + var $28=(($27+68)|0); + HEAP32[(($28)>>2)]=0; + var $29=$2; + var $30=$self; + var $31=(($30+56)|0); + HEAP32[(($31)>>2)]=$29; + var $32=$2; + var $33=$32; + var $34=(($33+28)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$35; + var $37=(($36+24)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$self; + var $40=(($39)|0); + var $41=(($40+24)|0); + HEAP32[(($41)>>2)]=$38; + var $42=$2; + var $43=$42; + var $44=(($43+28)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$45; + var $47=(($46+28)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48)|0)!=0; + if ($49) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $51=$2; + var $52=$51; + var $53=(($52+28)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=$54; + var $56=(($55+28)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=(($ctx)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=(($ctx+4)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=_ast_type_copy($59, $61, $57); + var $63=$self; + var $64=(($63)|0); + var $65=(($64+28)|0); + HEAP32[(($65)>>2)]=$62; + __label__ = 6; break; + case 6: + var $67=$self; + $1=$67; + __label__ = 7; break; + case 7: + var $69=$1; + STACKTOP = __stackBase__; + return $69; + default: assert(0, "bad label: " + __label__); + } +} +_ast_call_new["X"]=1; + +function _ast_call_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=$1; + var $5=(($4+64)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) < (($6)>>>0); + if ($7) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + __label__ = 5; break; + case 5: + var $10=$i; + var $11=$1; + var $12=(($11+60)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$15; + var $17=$16; + var $18=(($17+16)|0); + var $19=HEAP8[($18)]; + var $20=(($19) & 1); + if ($20) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $22=$i; + var $23=$1; + var $24=(($23+60)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25+($22<<2))|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$27; + var $29=$28; + var $30=(($29+8)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=$i; + var $33=$1; + var $34=(($33+60)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+($32<<2))|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + FUNCTION_TABLE[$31]($38); + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + var $42=$i; + var $43=((($42)+(1))|0); + $i=$43; + __label__ = 3; break; + case 10: + var $45=$1; + var $46=(($45+60)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($47)|0)!=0; + if ($48) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $50=$1; + var $51=(($50+60)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=$52; + _util_memory_d($53, 664, ((STRING_TABLE.__str)|0)); + __label__ = 12; break; + case 12: + var $55=$1; + var $56=(($55+60)|0); + HEAP32[(($56)>>2)]=0; + var $57=$1; + var $58=(($57+64)|0); + HEAP32[(($58)>>2)]=0; + var $59=$1; + var $60=(($59+68)|0); + HEAP32[(($60)>>2)]=0; + var $61=$1; + var $62=(($61+56)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63)|0)!=0; + if ($64) { __label__ = 13; break; } else { __label__ = 18; break; } + case 13: + __label__ = 14; break; + case 14: + var $67=$1; + var $68=(($67+56)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=$69; + var $71=$70; + var $72=(($71+16)|0); + var $73=HEAP8[($72)]; + var $74=(($73) & 1); + if ($74) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $76=$1; + var $77=(($76+56)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$78; + var $80=$79; + var $81=(($80+8)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=$1; + var $84=(($83+56)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=$85; + FUNCTION_TABLE[$82]($86); + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + __label__ = 18; break; + case 18: + var $90=$1; + var $91=$90; + _ast_expression_delete($91); + var $92=$1; + var $93=$92; + _util_memory_d($93, 670, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_call_delete["X"]=1; + +function _ast_call_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 20; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $params=__stackBase__; + var $callinstr; + var $i; + var $funval=(__stackBase__)+(12); + var $param=(__stackBase__)+(16); + var $expr; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + HEAP32[(($funval)>>2)]=0; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((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)); + $1=0; + __label__ = 34; break; + case 4: + var $18=$2; + var $19=(($18)|0); + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $24=$2; + var $25=(($24)|0); + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$5; + HEAP32[(($28)>>2)]=$27; + $1=1; + __label__ = 34; break; + case 6: + var $30=$2; + var $31=(($30+56)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$32; + var $34=(($33+20)|0); + var $35=HEAP32[(($34)>>2)]; + $cgen=$35; + var $36=$cgen; + var $37=$2; + var $38=(($37+56)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$3; + var $41=FUNCTION_TABLE[$36]($39, $40, 0, $funval); + if ($41) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 34; break; + case 8: + var $44=HEAP32[(($funval)>>2)]; + var $45=(($44)|0)!=0; + if ($45) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 34; break; + case 10: + var $48=(($params)|0); + HEAP32[(($48)>>2)]=0; + var $49=(($params+4)|0); + HEAP32[(($49)>>2)]=0; + var $50=(($params+8)|0); + HEAP32[(($50)>>2)]=0; + $i=0; + __label__ = 11; break; + case 11: + var $52=$i; + var $53=$2; + var $54=(($53+64)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($52)>>>0) < (($55)>>>0); + if ($56) { __label__ = 12; break; } else { __label__ = 20; break; } + case 12: + var $58=$i; + var $59=$2; + var $60=(($59+60)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61+($58<<2))|0); + var $63=HEAP32[(($62)>>2)]; + $expr=$63; + var $64=$expr; + var $65=$64; + var $66=(($65+20)|0); + var $67=HEAP32[(($66)>>2)]; + $cgen=$67; + var $68=$cgen; + var $69=$expr; + var $70=$3; + var $71=FUNCTION_TABLE[$68]($69, $70, 0, $param); + if ($71) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + __label__ = 31; break; + case 14: + var $74=HEAP32[(($param)>>2)]; + var $75=(($74)|0)!=0; + if ($75) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + __label__ = 31; break; + case 16: + var $78=HEAP32[(($param)>>2)]; + var $79=_ir_value_vector_v_add($params, $78); + if ($79) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + __label__ = 31; break; + case 18: + __label__ = 19; break; + case 19: + var $83=$i; + var $84=((($83)+(1))|0); + $i=$84; + __label__ = 11; break; + case 20: + var $86=$3; + var $87=(($86+36)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=$3; + var $90=_ast_function_label($89, ((STRING_TABLE.__str41)|0)); + var $91=HEAP32[(($funval)>>2)]; + var $92=_ir_block_create_call($88, $90, $91); + $callinstr=$92; + var $93=$callinstr; + var $94=(($93)|0)!=0; + if ($94) { __label__ = 22; break; } else { __label__ = 21; break; } + case 21: + __label__ = 31; break; + case 22: + $i=0; + __label__ = 23; break; + case 23: + var $98=$i; + var $99=(($params+4)|0); + var $100=HEAP32[(($99)>>2)]; + var $101=(($98)>>>0) < (($100)>>>0); + if ($101) { __label__ = 24; break; } else { __label__ = 28; break; } + case 24: + var $103=$callinstr; + var $104=$i; + var $105=(($params)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=(($106+($104<<2))|0); + var $108=HEAP32[(($107)>>2)]; + var $109=_ir_call_param($103, $108); + if ($109) { __label__ = 26; break; } else { __label__ = 25; break; } + case 25: + __label__ = 31; break; + case 26: + __label__ = 27; break; + case 27: + var $113=$i; + var $114=((($113)+(1))|0); + $i=$114; + __label__ = 23; break; + case 28: + var $116=$callinstr; + var $117=_ir_call_value($116); + var $118=$5; + HEAP32[(($118)>>2)]=$117; + var $119=$5; + var $120=HEAP32[(($119)>>2)]; + var $121=$2; + var $122=(($121)|0); + var $123=(($122+52)|0); + HEAP32[(($123)>>2)]=$120; + var $124=(($params)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=(($125)|0)!=0; + if ($126) { __label__ = 29; break; } else { __label__ = 30; break; } + case 29: + var $128=(($params)|0); + var $129=HEAP32[(($128)>>2)]; + var $130=$129; + _util_memory_d($130, 1892, ((STRING_TABLE.__str)|0)); + __label__ = 30; break; + case 30: + var $132=(($params)|0); + HEAP32[(($132)>>2)]=0; + var $133=(($params+4)|0); + HEAP32[(($133)>>2)]=0; + var $134=(($params+8)|0); + HEAP32[(($134)>>2)]=0; + $1=1; + __label__ = 34; break; + case 31: + var $136=(($params)|0); + var $137=HEAP32[(($136)>>2)]; + var $138=(($137)|0)!=0; + if ($138) { __label__ = 32; break; } else { __label__ = 33; break; } + case 32: + var $140=(($params)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=$141; + _util_memory_d($142, 1895, ((STRING_TABLE.__str)|0)); + __label__ = 33; break; + case 33: + var $144=(($params)|0); + HEAP32[(($144)>>2)]=0; + var $145=(($params+4)|0); + HEAP32[(($145)>>2)]=0; + var $146=(($params+8)|0); + HEAP32[(($146)>>2)]=0; + $1=0; + __label__ = 34; break; + case 34: + var $148=$1; + STACKTOP = __stackBase__; + return $148; + default: assert(0, "bad label: " + __label__); + } +} +_ast_call_codegen["X"]=1; + +function _ast_call_params_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+64)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+68)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+68)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+68)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+68)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+68)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 657, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+64)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+60)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 657, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+60)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+64)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+60)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_call_params_add["X"]=1; + +function _ast_call_check_types($self) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + var $retval; + var $func; + var $count; + $1=$self; + $retval=1; + var $2=$1; + var $3=(($2+56)|0); + var $4=HEAP32[(($3)>>2)]; + $func=$4; + var $5=$1; + var $6=(($5+64)|0); + var $7=HEAP32[(($6)>>2)]; + $count=$7; + var $8=$count; + var $9=$func; + var $10=$9; + var $11=(($10+36)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($8)>>>0) > (($12)>>>0); + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$func; + var $16=$15; + var $17=(($16+36)|0); + var $18=HEAP32[(($17)>>2)]; + $count=$18; + __label__ = 4; break; + case 4: + $i=0; + __label__ = 5; break; + case 5: + var $21=$i; + var $22=$count; + var $23=(($21)>>>0) < (($22)>>>0); + if ($23) { __label__ = 6; break; } else { __label__ = 10; break; } + case 6: + var $25=$i; + var $26=$1; + var $27=(($26+60)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28+($25<<2))|0); + var $30=HEAP32[(($29)>>2)]; + var $31=$i; + var $32=$func; + var $33=$32; + var $34=(($33+32)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+($31<<2))|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=_ast_compare_type($30, $38); + if ($39) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $41=$1; + var $42=$41; + var $43=(($42)|0); + var $44=$i; + var $45=((($44)+(1))|0); + var $46=(($43)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($43+4)|0); + var $49=HEAP32[(($48)>>2)]; + _asterror($47, $49, ((STRING_TABLE.__str3)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$45,tempInt)); + $retval=0; + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + var $52=$i; + var $53=((($52)+(1))|0); + $i=$53; + __label__ = 5; break; + case 10: + var $55=$retval; + var $56=(($55) & 1); + STACKTOP = __stackBase__; + return $56; + default: assert(0, "bad label: " + __label__); + } +} +_ast_call_check_types["X"]=1; + +function _ast_store_new($ctx_0, $ctx_1, $op, $dest, $source) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $4; + var $self; + var $5=(($ctx)|0); + HEAP32[(($5)>>2)]=$ctx_0; + var $6=(($ctx+4)|0); + HEAP32[(($6)>>2)]=$ctx_1; + $2=$op; + $3=$dest; + $4=$source; + var $7=_util_memory_a(68, 696, ((STRING_TABLE.__str)|0)); + var $8=$7; + $self=$8; + var $9=$self; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 10; break; + case 4: + var $13=$self; + var $14=$13; + var $15=(($ctx)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($ctx+4)|0); + var $18=HEAP32[(($17)>>2)]; + _ast_node_init($14, $16, $18, 6); + var $19=$self; + var $20=$19; + var $21=$20; + var $22=(($21+8)|0); + HEAP32[(($22)>>2)]=(26); + var $23=$self; + var $24=$23; + _ast_expression_init($24, (48)); + var $25=$2; + var $26=$self; + var $27=(($26+56)|0); + HEAP32[(($27)>>2)]=$25; + var $28=$3; + var $29=$self; + var $30=(($29+60)|0); + HEAP32[(($30)>>2)]=$28; + var $31=$4; + var $32=$self; + var $33=(($32+64)|0); + HEAP32[(($33)>>2)]=$31; + var $34=$3; + var $35=$34; + var $36=(($35+24)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$self; + var $39=(($38)|0); + var $40=(($39+24)|0); + HEAP32[(($40)>>2)]=$37; + var $41=$3; + var $42=$41; + var $43=(($42+28)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($44)|0)!=0; + if ($45) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $47=$3; + var $48=(($ctx)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($ctx+4)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=_ast_type_copy($49, $51, $47); + var $53=$self; + var $54=(($53)|0); + var $55=(($54+28)|0); + HEAP32[(($55)>>2)]=$52; + var $56=$self; + var $57=(($56)|0); + var $58=(($57+28)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $62=$self; + var $63=$62; + var $64=$63; + var $65=(($64+8)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=$self; + var $68=$67; + FUNCTION_TABLE[$66]($68); + $1=0; + __label__ = 10; break; + case 7: + __label__ = 9; break; + case 8: + var $71=$self; + var $72=(($71)|0); + var $73=(($72+28)|0); + HEAP32[(($73)>>2)]=0; + __label__ = 9; break; + case 9: + var $75=$self; + $1=$75; + __label__ = 10; break; + case 10: + var $77=$1; + STACKTOP = __stackBase__; + return $77; + default: assert(0, "bad label: " + __label__); + } +} +_ast_store_new["X"]=1; + +function _ast_store_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + __label__ = 3; break; + case 3: + var $3=$1; + var $4=(($3+60)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$5; + var $7=$6; + var $8=(($7+16)|0); + var $9=HEAP8[($8)]; + var $10=(($9) & 1); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$1; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$14; + var $16=$15; + var $17=(($16+8)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+60)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$18]($22); + __label__ = 5; break; + case 5: + __label__ = 6; break; + case 6: + __label__ = 7; break; + case 7: + var $26=$1; + var $27=(($26+64)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$28; + var $30=$29; + var $31=(($30+16)|0); + var $32=HEAP8[($31)]; + var $33=(($32) & 1); + if ($33) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $35=$1; + var $36=(($35+64)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=$38; + var $40=(($39+8)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$1; + var $43=(($42+64)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$44; + FUNCTION_TABLE[$41]($45); + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $48=$1; + var $49=$48; + _ast_expression_delete($49); + var $50=$1; + var $51=$50; + _util_memory_d($51, 722, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_store_delete["X"]=1; + +function _ast_store_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $cgen; + var $left=__stackBase__; + var $right=(__stackBase__)+(4); + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $10=$2; + var $11=(($10)|0); + var $12=(($11+48)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $16=$2; + var $17=(($16)|0); + var $18=(($17+48)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$5; + HEAP32[(($20)>>2)]=$19; + $1=1; + __label__ = 18; break; + case 5: + var $22=$4; + var $23=(($22) & 1); + if ($23) { __label__ = 8; break; } else { __label__ = 6; break; } + case 6: + var $25=$2; + var $26=(($25)|0); + var $27=(($26+52)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $31=$2; + var $32=(($31)|0); + var $33=(($32+52)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$5; + HEAP32[(($35)>>2)]=$34; + $1=1; + __label__ = 18; break; + case 8: + var $37=$2; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + $cgen=$42; + var $43=$cgen; + var $44=$2; + var $45=(($44+60)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$3; + var $48=FUNCTION_TABLE[$43]($46, $47, 1, $left); + if ($48) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 18; break; + case 10: + var $51=HEAP32[(($left)>>2)]; + var $52=$2; + var $53=(($52)|0); + var $54=(($53+48)|0); + HEAP32[(($54)>>2)]=$51; + var $55=$2; + var $56=(($55+64)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$57; + var $59=(($58+20)|0); + var $60=HEAP32[(($59)>>2)]; + $cgen=$60; + var $61=$cgen; + var $62=$2; + var $63=(($62+64)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=$3; + var $66=FUNCTION_TABLE[$61]($64, $65, 0, $right); + if ($66) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 18; break; + case 12: + var $69=$3; + var $70=(($69+36)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$2; + var $73=(($72+56)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=HEAP32[(($left)>>2)]; + var $76=HEAP32[(($right)>>2)]; + var $77=_ir_block_create_store_op($71, $74, $75, $76); + if ($77) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + $1=0; + __label__ = 18; break; + case 14: + var $80=HEAP32[(($right)>>2)]; + var $81=$2; + var $82=(($81)|0); + var $83=(($82+52)|0); + HEAP32[(($83)>>2)]=$80; + var $84=$4; + var $85=(($84) & 1); + if ($85) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $87=HEAP32[(($left)>>2)]; + var $91 = $87;__label__ = 17; break; + case 16: + var $89=HEAP32[(($right)>>2)]; + var $91 = $89;__label__ = 17; break; + case 17: + var $91; + var $92=$5; + HEAP32[(($92)>>2)]=$91; + $1=1; + __label__ = 18; break; + case 18: + var $94=$1; + STACKTOP = __stackBase__; + return $94; + default: assert(0, "bad label: " + __label__); + } +} +_ast_store_codegen["X"]=1; + +function _ast_block_new($ctx_0, $ctx_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $self; + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + var $4=_util_memory_a(92, 727, ((STRING_TABLE.__str)|0)); + var $5=$4; + $self=$5; + var $6=$self; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $10=$self; + var $11=$10; + var $12=(($ctx)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($ctx+4)|0); + var $15=HEAP32[(($14)>>2)]; + _ast_node_init($11, $13, $15, 4); + var $16=$self; + var $17=$16; + var $18=$17; + var $19=(($18+8)|0); + HEAP32[(($19)>>2)]=(54); + var $20=$self; + var $21=$20; + _ast_expression_init($21, (56)); + var $22=$self; + var $23=(($22+56)|0); + HEAP32[(($23)>>2)]=0; + var $24=$self; + var $25=(($24+60)|0); + HEAP32[(($25)>>2)]=0; + var $26=$self; + var $27=(($26+64)|0); + HEAP32[(($27)>>2)]=0; + var $28=$self; + var $29=(($28+68)|0); + HEAP32[(($29)>>2)]=0; + var $30=$self; + var $31=(($30+72)|0); + HEAP32[(($31)>>2)]=0; + var $32=$self; + var $33=(($32+76)|0); + HEAP32[(($33)>>2)]=0; + var $34=$self; + var $35=(($34+80)|0); + HEAP32[(($35)>>2)]=0; + var $36=$self; + var $37=(($36+84)|0); + HEAP32[(($37)>>2)]=0; + var $38=$self; + var $39=(($38+88)|0); + HEAP32[(($39)>>2)]=0; + var $40=$self; + $1=$40; + __label__ = 5; break; + case 5: + var $42=$1; + STACKTOP = __stackBase__; + return $42; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_new["X"]=1; + +function _ast_block_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=$1; + var $5=(($4+72)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) < (($6)>>>0); + if ($7) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + __label__ = 5; break; + case 5: + var $10=$i; + var $11=$1; + var $12=(($11+68)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$15; + var $17=$16; + var $18=(($17+16)|0); + var $19=HEAP8[($18)]; + var $20=(($19) & 1); + if ($20) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $22=$i; + var $23=$1; + var $24=(($23+68)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25+($22<<2))|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$27; + var $29=$28; + var $30=(($29+8)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=$i; + var $33=$1; + var $34=(($33+68)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+($32<<2))|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + FUNCTION_TABLE[$31]($38); + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + var $42=$i; + var $43=((($42)+(1))|0); + $i=$43; + __label__ = 3; break; + case 10: + var $45=$1; + var $46=(($45+68)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($47)|0)!=0; + if ($48) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $50=$1; + var $51=(($50+68)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=$52; + _util_memory_d($53, 754, ((STRING_TABLE.__str)|0)); + __label__ = 12; break; + case 12: + var $55=$1; + var $56=(($55+68)|0); + HEAP32[(($56)>>2)]=0; + var $57=$1; + var $58=(($57+72)|0); + HEAP32[(($58)>>2)]=0; + var $59=$1; + var $60=(($59+76)|0); + HEAP32[(($60)>>2)]=0; + $i=0; + __label__ = 13; break; + case 13: + var $62=$i; + var $63=$1; + var $64=(($63+60)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($62)>>>0) < (($65)>>>0); + if ($66) { __label__ = 14; break; } else { __label__ = 16; break; } + case 14: + var $68=$i; + var $69=$1; + var $70=(($69+56)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=(($71+($68<<2))|0); + var $73=HEAP32[(($72)>>2)]; + var $74=$73; + var $75=$74; + var $76=(($75+8)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=$i; + var $79=$1; + var $80=(($79+56)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81+($78<<2))|0); + var $83=HEAP32[(($82)>>2)]; + var $84=$83; + FUNCTION_TABLE[$77]($84); + __label__ = 15; break; + case 15: + var $86=$i; + var $87=((($86)+(1))|0); + $i=$87; + __label__ = 13; break; + case 16: + var $89=$1; + var $90=(($89+56)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($91)|0)!=0; + if ($92) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $94=$1; + var $95=(($94+56)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=$96; + _util_memory_d($97, 757, ((STRING_TABLE.__str)|0)); + __label__ = 18; break; + case 18: + var $99=$1; + var $100=(($99+56)|0); + HEAP32[(($100)>>2)]=0; + var $101=$1; + var $102=(($101+60)|0); + HEAP32[(($102)>>2)]=0; + var $103=$1; + var $104=(($103+64)|0); + HEAP32[(($104)>>2)]=0; + $i=0; + __label__ = 19; break; + case 19: + var $106=$i; + var $107=$1; + var $108=(($107+84)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=(($106)>>>0) < (($109)>>>0); + if ($110) { __label__ = 20; break; } else { __label__ = 22; break; } + case 20: + var $112=$i; + var $113=$1; + var $114=(($113+80)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=(($115+($112<<2))|0); + var $117=HEAP32[(($116)>>2)]; + var $118=$117; + var $119=$118; + var $120=(($119+8)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=$i; + var $123=$1; + var $124=(($123+80)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=(($125+($122<<2))|0); + var $127=HEAP32[(($126)>>2)]; + var $128=$127; + FUNCTION_TABLE[$121]($128); + __label__ = 21; break; + case 21: + var $130=$i; + var $131=((($130)+(1))|0); + $i=$131; + __label__ = 19; break; + case 22: + var $133=$1; + var $134=(($133+80)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=(($135)|0)!=0; + if ($136) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + var $138=$1; + var $139=(($138+80)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=$140; + _util_memory_d($141, 760, ((STRING_TABLE.__str)|0)); + __label__ = 24; break; + case 24: + var $143=$1; + var $144=(($143+80)|0); + HEAP32[(($144)>>2)]=0; + var $145=$1; + var $146=(($145+84)|0); + HEAP32[(($146)>>2)]=0; + var $147=$1; + var $148=(($147+88)|0); + HEAP32[(($148)>>2)]=0; + var $149=$1; + var $150=$149; + _ast_expression_delete($150); + var $151=$1; + var $152=$151; + _util_memory_d($152, 762, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_delete["X"]=1; + +function _ast_block_codegen($self, $func, $lvalue, $out) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $i; + var $gen; + $2=$self; + $3=$func; + var $6=(($lvalue)&1); + $4=$6; + $5=$out; + var $7=$4; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((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)); + $1=0; + __label__ = 21; break; + case 4: + var $18=$2; + var $19=(($18)|0); + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $24=$2; + var $25=(($24)|0); + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$5; + HEAP32[(($28)>>2)]=$27; + $1=1; + __label__ = 21; break; + case 6: + var $30=$5; + HEAP32[(($30)>>2)]=0; + $i=0; + __label__ = 7; break; + case 7: + var $32=$i; + var $33=$2; + var $34=(($33+60)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($32)>>>0) < (($35)>>>0); + if ($36) { __label__ = 8; break; } else { __label__ = 14; break; } + case 8: + var $38=$i; + var $39=$2; + var $40=(($39+56)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=(($41+($38<<2))|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$3; + var $45=(($44+32)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=_ast_local_codegen($43, $46, 0); + if ($47) { __label__ = 12; break; } else { __label__ = 9; break; } + case 9: + var $49=HEAP8[(_opts_debug)]; + var $50=(($49) & 1); + if ($50) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $52=$2; + var $53=$52; + var $54=(($53)|0); + var $55=$i; + var $56=$2; + var $57=(($56+56)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($55<<2))|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+56)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($54)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($54+4)|0); + var $66=HEAP32[(($65)>>2)]; + _asterror($64, $66, ((STRING_TABLE.__str14)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$62,tempInt)); + __label__ = 11; break; + case 11: + $1=0; + __label__ = 21; break; + case 12: + __label__ = 13; break; + case 13: + var $70=$i; + var $71=((($70)+(1))|0); + $i=$71; + __label__ = 7; break; + case 14: + $i=0; + __label__ = 15; break; + case 15: + var $74=$i; + var $75=$2; + var $76=(($75+72)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=(($74)>>>0) < (($77)>>>0); + if ($78) { __label__ = 16; break; } else { __label__ = 20; break; } + case 16: + var $80=$i; + var $81=$2; + var $82=(($81+68)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=(($83+($80<<2))|0); + var $85=HEAP32[(($84)>>2)]; + var $86=$85; + var $87=(($86+20)|0); + var $88=HEAP32[(($87)>>2)]; + $gen=$88; + var $89=$gen; + var $90=$i; + var $91=$2; + var $92=(($91+68)|0); + var $93=HEAP32[(($92)>>2)]; + var $94=(($93+($90<<2))|0); + var $95=HEAP32[(($94)>>2)]; + var $96=$3; + var $97=$5; + var $98=FUNCTION_TABLE[$89]($95, $96, 0, $97); + if ($98) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 21; break; + case 18: + __label__ = 19; break; + case 19: + var $102=$i; + var $103=((($102)+(1))|0); + $i=$103; + __label__ = 15; break; + case 20: + var $105=$5; + var $106=HEAP32[(($105)>>2)]; + var $107=$2; + var $108=(($107)|0); + var $109=(($108+52)|0); + HEAP32[(($109)>>2)]=$106; + $1=1; + __label__ = 21; break; + case 21: + var $111=$1; + STACKTOP = __stackBase__; + return $111; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_codegen["X"]=1; + +function _ast_block_locals_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+60)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+64)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+64)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+64)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+64)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+64)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 737, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+56)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+60)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+56)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 737, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+56)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+60)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+56)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_locals_add["X"]=1; + +function _ast_block_exprs_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+72)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+76)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+76)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+76)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+76)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+76)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 738, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+68)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+72)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+68)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 738, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+68)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+72)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+68)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_exprs_add["X"]=1; + +function _ast_block_collect_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+84)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+88)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+88)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+88)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+88)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+88)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 739, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+80)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+84)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+80)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 739, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+80)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+84)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+80)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_collect_add["X"]=1; + +function _ast_block_collect($self, $expr) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$expr; + var $4=$2; + var $5=$3; + var $6=_ast_block_collect_add($4, $5); + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $9=$3; + var $10=$9; + var $11=(($10)|0); + var $12=(($11+16)|0); + HEAP8[($12)]=1; + $1=1; + __label__ = 5; break; + case 5: + var $14=$1; + ; + return $14; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ast_block_set_type($self, $from) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$from; + var $4=$2; + var $5=(($4)|0); + var $6=(($5+28)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $10=$2; + var $11=(($10)|0); + var $12=(($11+28)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$13; + var $15=$14; + var $16=(($15+8)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$2; + var $19=(($18)|0); + var $20=(($19+28)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21; + FUNCTION_TABLE[$17]($22); + __label__ = 4; break; + case 4: + var $24=$3; + var $25=$24; + var $26=(($25+24)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$2; + var $29=(($28)|0); + var $30=(($29+24)|0); + HEAP32[(($30)>>2)]=$27; + var $31=$3; + var $32=$31; + var $33=(($32+28)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($34)|0)!=0; + if ($35) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $37=$2; + var $38=(($37)|0); + var $39=(($38)|0); + var $40=(($39)|0); + var $41=$3; + var $42=$41; + var $43=(($42+28)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($40)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($40+4)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=_ast_type_copy($46, $48, $44); + var $50=$2; + var $51=(($50)|0); + var $52=(($51+28)|0); + HEAP32[(($52)>>2)]=$49; + var $53=$2; + var $54=(($53)|0); + var $55=(($54+28)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + $1=0; + __label__ = 10; break; + case 7: + __label__ = 9; break; + case 8: + var $61=$2; + var $62=(($61)|0); + var $63=(($62+28)|0); + HEAP32[(($63)>>2)]=0; + __label__ = 9; break; + case 9: + $1=1; + __label__ = 10; break; + case 10: + var $66=$1; + ; + return $66; + default: assert(0, "bad label: " + __label__); + } +} +_ast_block_set_type["X"]=1; + +function _ast_function_new($ctx_0, $ctx_1, $name, $vtype) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $self; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$name; + $3=$vtype; + var $6=_util_memory_a(128, 782, ((STRING_TABLE.__str)|0)); + var $7=$6; + $self=$7; + var $8=$self; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 12; break; + case 4: + var $12=$self; + var $13=$12; + var $14=(($ctx)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($ctx+4)|0); + var $17=HEAP32[(($16)>>2)]; + _ast_node_init($13, $15, $17, 3); + var $18=$self; + var $19=$18; + var $20=$19; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=(32); + var $22=$3; + var $23=(($22)|0)!=0; + if ($23) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $25=$3; + var $26=(($25+60)|0); + var $27=HEAP8[($26)]; + var $28=(($27) & 1); + if ($28) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $30=$3; + var $31=(($30)|0); + var $32=(($31+24)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33)|0)!=6; + if ($34) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $36=$self; + var $37=$36; + _util_memory_d($37, 788, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 12; break; + case 8: + var $39=$3; + var $40=$self; + var $41=(($40+20)|0); + HEAP32[(($41)>>2)]=$39; + var $42=$2; + var $43=(($42)|0)!=0; + if ($43) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $45=$2; + var $46=_util_strdup($45); + var $49 = $46;__label__ = 11; break; + case 10: + var $49 = 0;__label__ = 11; break; + case 11: + var $49; + var $50=$self; + var $51=(($50+24)|0); + HEAP32[(($51)>>2)]=$49; + var $52=$self; + var $53=(($52+116)|0); + HEAP32[(($53)>>2)]=0; + var $54=$self; + var $55=(($54+120)|0); + HEAP32[(($55)>>2)]=0; + var $56=$self; + var $57=(($56+124)|0); + HEAP32[(($57)>>2)]=0; + var $58=$self; + var $59=(($58+48)|0); + HEAP32[(($59)>>2)]=0; + var $60=$self; + var $61=(($60+28)|0); + HEAP32[(($61)>>2)]=0; + var $62=$self; + var $63=(($62+32)|0); + HEAP32[(($63)>>2)]=0; + var $64=$self; + var $65=(($64+36)|0); + HEAP32[(($65)>>2)]=0; + var $66=$self; + var $67=(($66+40)|0); + HEAP32[(($67)>>2)]=0; + var $68=$self; + var $69=(($68+44)|0); + HEAP32[(($69)>>2)]=0; + var $70=$3; + var $71=(($70+60)|0); + HEAP8[($71)]=1; + var $72=$self; + var $73=$3; + var $74=(($73+64)|0); + var $75=$74; + HEAP32[(($75)>>2)]=$72; + var $76=$self; + $1=$76; + __label__ = 12; break; + case 12: + var $78=$1; + STACKTOP = __stackBase__; + return $78; + default: assert(0, "bad label: " + __label__); + } +} +_ast_function_new["X"]=1; + +function _ast_function_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2+24)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 817, ((STRING_TABLE.__str)|0)); + __label__ = 4; break; + case 4: + var $11=$1; + var $12=(($11+20)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 10; break; } + case 5: + var $16=$1; + var $17=(($16+20)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+60)|0); + HEAP8[($19)]=0; + var $20=$1; + var $21=(($20+20)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22+64)|0); + var $24=$23; + HEAP32[(($24)>>2)]=0; + __label__ = 6; break; + case 6: + var $26=$1; + var $27=(($26+20)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$28; + var $30=$29; + var $31=(($30+16)|0); + var $32=HEAP8[($31)]; + var $33=(($32) & 1); + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $35=$1; + var $36=(($35+20)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$37; + var $39=$38; + var $40=(($39+8)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$1; + var $43=(($42+20)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$44; + FUNCTION_TABLE[$41]($45); + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + $i=0; + __label__ = 11; break; + case 11: + var $50=$i; + var $51=$1; + var $52=(($51+120)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($50)>>>0) < (($53)>>>0); + if ($54) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $56=$i; + var $57=$1; + var $58=(($57+116)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=(($59+($56<<2))|0); + var $61=HEAP32[(($60)>>2)]; + var $62=$61; + var $63=$62; + var $64=(($63+8)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=$i; + var $67=$1; + var $68=(($67+116)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=(($69+($66<<2))|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$71; + FUNCTION_TABLE[$65]($72); + __label__ = 13; break; + case 13: + var $74=$i; + var $75=((($74)+(1))|0); + $i=$75; + __label__ = 11; break; + case 14: + var $77=$1; + var $78=(($77+116)|0); + var $79=HEAP32[(($78)>>2)]; + var $80=(($79)|0)!=0; + if ($80) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $82=$1; + var $83=(($82+116)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=$84; + _util_memory_d($85, 829, ((STRING_TABLE.__str)|0)); + __label__ = 16; break; + case 16: + var $87=$1; + var $88=(($87+116)|0); + HEAP32[(($88)>>2)]=0; + var $89=$1; + var $90=(($89+120)|0); + HEAP32[(($90)>>2)]=0; + var $91=$1; + var $92=(($91+124)|0); + HEAP32[(($92)>>2)]=0; + var $93=$1; + var $94=$93; + _util_memory_d($94, 830, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ast_function_delete["X"]=1; + +function _ast_function_blocks_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+120)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+124)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+124)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+124)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+124)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+124)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 811, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+116)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+120)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+116)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 811, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+116)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+120)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+116)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ast_function_blocks_add["X"]=1; + +function _ast_function_label($self, $prefix) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $id; + var $len; + var $from; + var $digit; + $2=$self; + $3=$prefix; + var $4=HEAP8[(_opts_dump)]; + var $5=(($4) & 1); + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 8; break; + case 4: + var $8=$2; + var $9=(($8+48)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=((($10)+(1))|0); + HEAP32[(($9)>>2)]=$11; + $id=$10; + var $12=$3; + var $13=_strlen($12); + $len=$13; + var $14=$2; + var $15=(($14+52)|0); + var $16=(($15)|0); + var $17=(($16+64)|0); + var $18=((($17)-(1))|0); + $from=$18; + var $19=$from; + var $20=((($19)-(1))|0); + $from=$20; + HEAP8[($19)]=0; + __label__ = 5; break; + case 5: + var $22=$id; + var $23=((($22)>>>0))%(10); + $digit=$23; + var $24=$digit; + var $25=((($24)+(48))|0); + var $26=(($25) & 255); + var $27=$from; + HEAP8[($27)]=$26; + var $28=$id; + var $29=Math.floor(((($28)>>>0))/(10)); + $id=$29; + __label__ = 6; break; + case 6: + var $31=$id; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 5; break; } else { __label__ = 7; break; } + case 7: + var $34=$from; + var $35=$len; + var $36=(((-$35))|0); + var $37=(($34+$36)|0); + var $38=$3; + var $39=$len; + assert($39 % 1 === 0, 'memcpy given ' + $39 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $38, $39, 1); + var $40=$from; + var $41=$len; + var $42=(((-$41))|0); + var $43=(($40+$42)|0); + $1=$43; + __label__ = 8; break; + case 8: + var $45=$1; + ; + return $45; + default: assert(0, "bad label: " + __label__); + } +} +_ast_function_label["X"]=1; + +function _ast_global_codegen($self, $ir) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $v; + var $func; + $2=$self; + $3=$ir; + $v=0; + var $4=$2; + var $5=(($4+60)|0); + var $6=HEAP8[($5)]; + var $7=(($6) & 1); + if ($7) { __label__ = 3; break; } else { __label__ = 7; break; } + case 3: + var $9=$2; + var $10=(($9)|0); + var $11=(($10+24)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)==6; + if ($13) { __label__ = 4; break; } else { __label__ = 7; break; } + case 4: + var $15=$3; + var $16=$2; + var $17=(($16+56)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$2; + var $20=(($19)|0); + var $21=(($20+28)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=$22; + var $24=(($23+24)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=_ir_builder_create_function($15, $18, $25); + $func=$26; + var $27=$func; + var $28=(($27)|0)!=0; + if ($28) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 31; break; + case 6: + var $31=$func; + var $32=(($31+76)|0); + var $33=$2; + var $34=$33; + var $35=(($34)|0); + var $36=$32; + var $37=$35; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($36)>>2)]=HEAP32[(($37)>>2)];HEAP32[((($36)+(4))>>2)]=HEAP32[((($37)+(4))>>2)]; + var $38=$func; + var $39=(($38+36)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40+12)|0); + var $42=$2; + var $43=$42; + var $44=(($43)|0); + var $45=$41; + var $46=$44; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($45)>>2)]=HEAP32[(($46)>>2)];HEAP32[((($45)+(4))>>2)]=HEAP32[((($46)+(4))>>2)]; + var $47=$func; + var $48=$2; + var $49=(($48+64)|0); + var $50=$49; + var $51=HEAP32[(($50)>>2)]; + var $52=(($51+32)|0); + HEAP32[(($52)>>2)]=$47; + var $53=$func; + var $54=(($53+36)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$2; + var $57=(($56+80)|0); + HEAP32[(($57)>>2)]=$55; + $1=1; + __label__ = 31; break; + case 7: + var $59=$2; + var $60=(($59)|0); + var $61=(($60+24)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)==5; + if ($63) { __label__ = 8; break; } else { __label__ = 13; break; } + case 8: + var $65=$3; + var $66=$2; + var $67=(($66+56)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$2; + var $70=(($69)|0); + var $71=(($70+28)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=$72; + var $74=(($73+24)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=_ir_builder_create_field($65, $68, $75); + $v=$76; + var $77=$v; + var $78=(($77)|0)!=0; + if ($78) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 31; break; + case 10: + var $81=$v; + var $82=(($81+12)|0); + var $83=$2; + var $84=$83; + var $85=(($84)|0); + var $86=$82; + var $87=$85; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($86)>>2)]=HEAP32[(($87)>>2)];HEAP32[((($86)+(4))>>2)]=HEAP32[((($87)+(4))>>2)]; + var $88=$2; + var $89=(($88+60)|0); + var $90=HEAP8[($89)]; + var $91=(($90) & 1); + if ($91) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $93=$2; + var $94=$93; + var $95=(($94)|0); + var $96=(($95)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($95+4)|0); + var $99=HEAP32[(($98)>>2)]; + _asterror($97, $99, ((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)); + __label__ = 30; break; + case 12: + var $101=$v; + var $102=$2; + var $103=(($102+80)|0); + HEAP32[(($103)>>2)]=$101; + $1=1; + __label__ = 31; break; + case 13: + var $105=$3; + var $106=$2; + var $107=(($106+56)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=$2; + var $110=(($109)|0); + var $111=(($110+24)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=_ir_builder_create_global($105, $108, $112); + $v=$113; + var $114=$v; + var $115=(($114)|0)!=0; + if ($115) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + var $117=$2; + var $118=$117; + var $119=(($118)|0); + var $120=(($119)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=(($119+4)|0); + var $123=HEAP32[(($122)>>2)]; + _asterror($121, $123, ((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)); + $1=0; + __label__ = 31; break; + case 15: + var $125=$v; + var $126=(($125+12)|0); + var $127=$2; + var $128=$127; + var $129=(($128)|0); + var $130=$126; + var $131=$129; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($130)>>2)]=HEAP32[(($131)>>2)];HEAP32[((($130)+(4))>>2)]=HEAP32[((($131)+(4))>>2)]; + var $132=$2; + var $133=(($132+60)|0); + var $134=HEAP8[($133)]; + var $135=(($134) & 1); + if ($135) { __label__ = 16; break; } else { __label__ = 29; break; } + case 16: + var $137=$2; + var $138=(($137)|0); + var $139=(($138+24)|0); + var $140=HEAP32[(($139)>>2)]; + if ((($140)|0) == 2) { + __label__ = 17; break; + } + else if ((($140)|0) == 3) { + __label__ = 20; break; + } + else if ((($140)|0) == 1) { + __label__ = 23; break; + } + else if ((($140)|0) == 6) { + __label__ = 26; break; + } + else { + __label__ = 27; break; + } + + case 17: + var $142=$v; + var $143=$2; + var $144=(($143+64)|0); + var $145=$144; + var $146=(tempDoubleI32[0]=HEAP32[(($145)>>2)],tempDoubleI32[1]=HEAP32[((($145)+(4))>>2)],tempDoubleF64[0]); + var $147=$146; + var $148=_ir_value_set_float($142, $147); + if ($148) { __label__ = 19; break; } else { __label__ = 18; break; } + case 18: + __label__ = 30; break; + case 19: + __label__ = 28; break; + case 20: + var $152=$v; + var $153=$2; + var $154=(($153+64)|0); + var $155=$154; + var $156=(($155)|0); + var $157=HEAPF32[(($156)>>2)]; + var $158=(($155+4)|0); + var $159=HEAPF32[(($158)>>2)]; + var $160=(($155+8)|0); + var $161=HEAPF32[(($160)>>2)]; + var $162=_ir_value_set_vector($152, $157, $159, $161); + if ($162) { __label__ = 22; break; } else { __label__ = 21; break; } + case 21: + __label__ = 30; break; + case 22: + __label__ = 28; break; + case 23: + var $166=$v; + var $167=$2; + var $168=(($167+64)|0); + var $169=$168; + var $170=HEAP32[(($169)>>2)]; + var $171=_ir_value_set_string($166, $170); + if ($171) { __label__ = 25; break; } else { __label__ = 24; break; } + case 24: + __label__ = 30; break; + case 25: + __label__ = 28; break; + case 26: + var $175=$2; + var $176=$175; + var $177=(($176)|0); + var $178=(($177)|0); + var $179=HEAP32[(($178)>>2)]; + var $180=(($177+4)|0); + var $181=HEAP32[(($180)>>2)]; + _asterror($179, $181, ((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)); + __label__ = 30; break; + case 27: + var $183=$2; + var $184=$183; + var $185=(($184)|0); + var $186=$2; + var $187=(($186)|0); + var $188=(($187+24)|0); + var $189=HEAP32[(($188)>>2)]; + var $190=(($185)|0); + var $191=HEAP32[(($190)>>2)]; + var $192=(($185+4)|0); + var $193=HEAP32[(($192)>>2)]; + _asterror($191, $193, ((STRING_TABLE.__str8)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$189,tempInt)); + __label__ = 28; break; + case 28: + __label__ = 29; break; + case 29: + var $196=$v; + var $197=$2; + var $198=(($197+80)|0); + HEAP32[(($198)>>2)]=$196; + $1=1; + __label__ = 31; break; + case 30: + var $200=$v; + _ir_value_delete($200); + $1=0; + __label__ = 31; break; + case 31: + var $202=$1; + STACKTOP = __stackBase__; + return $202; + default: assert(0, "bad label: " + __label__); + } +} +_ast_global_codegen["X"]=1; + +function _ast_local_codegen($self, $func, $param) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $v; + $2=$self; + $3=$func; + var $5=(($param)&1); + $4=$5; + $v=0; + var $6=$2; + var $7=(($6+60)|0); + var $8=HEAP8[($7)]; + var $9=(($8) & 1); + if ($9) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $11=$2; + var $12=(($11)|0); + var $13=(($12+24)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)==6; + if ($15) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $1=0; + __label__ = 22; break; + case 5: + var $18=$3; + var $19=$2; + var $20=(($19+56)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$2; + var $23=(($22)|0); + var $24=(($23+24)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=$4; + var $27=(($26) & 1); + var $28=_ir_function_create_local($18, $21, $25, $27); + $v=$28; + var $29=$v; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + $1=0; + __label__ = 22; break; + case 7: + var $33=$v; + var $34=(($33+12)|0); + var $35=$2; + var $36=$35; + var $37=(($36)|0); + var $38=$34; + var $39=$37; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($38)>>2)]=HEAP32[(($39)>>2)];HEAP32[((($38)+(4))>>2)]=HEAP32[((($39)+(4))>>2)]; + var $40=$2; + var $41=(($40+60)|0); + var $42=HEAP8[($41)]; + var $43=(($42) & 1); + if ($43) { __label__ = 8; break; } else { __label__ = 20; break; } + case 8: + var $45=$2; + var $46=(($45)|0); + var $47=(($46+24)|0); + var $48=HEAP32[(($47)>>2)]; + if ((($48)|0) == 2) { + __label__ = 9; break; + } + else if ((($48)|0) == 3) { + __label__ = 12; break; + } + else if ((($48)|0) == 1) { + __label__ = 15; break; + } + else { + __label__ = 18; break; + } + + case 9: + var $50=$v; + var $51=$2; + var $52=(($51+64)|0); + var $53=$52; + var $54=(tempDoubleI32[0]=HEAP32[(($53)>>2)],tempDoubleI32[1]=HEAP32[((($53)+(4))>>2)],tempDoubleF64[0]); + var $55=$54; + var $56=_ir_value_set_float($50, $55); + if ($56) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + __label__ = 21; break; + case 11: + __label__ = 19; break; + case 12: + var $60=$v; + var $61=$2; + var $62=(($61+64)|0); + var $63=$62; + var $64=(($63)|0); + var $65=HEAPF32[(($64)>>2)]; + var $66=(($63+4)|0); + var $67=HEAPF32[(($66)>>2)]; + var $68=(($63+8)|0); + var $69=HEAPF32[(($68)>>2)]; + var $70=_ir_value_set_vector($60, $65, $67, $69); + if ($70) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + __label__ = 21; break; + case 14: + __label__ = 19; break; + case 15: + var $74=$v; + var $75=$2; + var $76=(($75+64)|0); + var $77=$76; + var $78=HEAP32[(($77)>>2)]; + var $79=_ir_value_set_string($74, $78); + if ($79) { __label__ = 17; break; } else { __label__ = 16; break; } + case 16: + __label__ = 21; break; + case 17: + __label__ = 19; break; + case 18: + var $83=$2; + var $84=$83; + var $85=(($84)|0); + var $86=$2; + var $87=(($86)|0); + var $88=(($87+24)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($85)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($85+4)|0); + var $93=HEAP32[(($92)>>2)]; + _asterror($91, $93, ((STRING_TABLE.__str8)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$89,tempInt)); + __label__ = 19; break; + case 19: + __label__ = 20; break; + case 20: + var $96=$v; + var $97=$2; + var $98=(($97+80)|0); + HEAP32[(($98)>>2)]=$96; + $1=1; + __label__ = 22; break; + case 21: + var $100=$v; + _ir_value_delete($100); + $1=0; + __label__ = 22; break; + case 22: + var $102=$1; + STACKTOP = __stackBase__; + return $102; + default: assert(0, "bad label: " + __label__); + } +} +_ast_local_codegen["X"]=1; + +function _code_alloc_field($qcsize) { + ; + var __label__; + + var $1; + var $pos; + $1=$qcsize; + var $2=HEAP32[((_code_entfields)>>2)]; + $pos=$2; + var $3=$1; + var $4=HEAP32[((_code_entfields)>>2)]; + var $5=((($4)+($3))|0); + HEAP32[((_code_entfields)>>2)]=$5; + var $6=$pos; + ; + return $6; +} + + +function _ast_function_codegen($self, $ir) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $irf; + var $dummy=__stackBase__; + var $ec; + var $i; + var $gen; + $2=$self; + $3=$ir; + var $4=$2; + var $5=(($4+32)|0); + var $6=HEAP32[(($5)>>2)]; + $irf=$6; + var $7=$irf; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $10=$2; + var $11=$10; + var $12=(($11)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($12+4)|0); + var $16=HEAP32[(($15)>>2)]; + _asterror($14, $16, ((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)); + $1=0; + __label__ = 29; break; + case 4: + var $18=$2; + var $19=(($18+20)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20)|0); + $ec=$21; + $i=0; + __label__ = 5; break; + case 5: + var $23=$i; + var $24=$ec; + var $25=(($24+36)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($23)>>>0) < (($26)>>>0); + if ($27) { __label__ = 6; break; } else { __label__ = 14; break; } + case 6: + var $29=$irf; + var $30=$i; + var $31=$ec; + var $32=(($31+32)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33+($30<<2))|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0); + var $37=(($36+24)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=_ir_function_params_add($29, $38); + if ($39) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 29; break; + case 8: + var $42=$2; + var $43=(($42+28)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($44)|0)!=0; + if ($45) { __label__ = 12; break; } else { __label__ = 9; break; } + case 9: + var $47=$i; + var $48=$ec; + var $49=(($48+32)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($50+($47<<2))|0); + var $52=HEAP32[(($51)>>2)]; + var $53=$2; + var $54=(($53+32)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=_ast_local_codegen($52, $55, 1); + if ($56) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 29; break; + case 11: + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + var $61=$i; + var $62=((($61)+(1))|0); + $i=$62; + __label__ = 5; break; + case 14: + var $64=$2; + var $65=(($64+28)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=(($66)|0)!=0; + if ($67) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $69=$2; + var $70=(($69+28)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$irf; + var $73=(($72+32)|0); + HEAP32[(($73)>>2)]=$71; + $1=1; + __label__ = 29; break; + case 16: + var $75=$2; + var $76=(($75+120)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=(($77)|0)!=0; + if ($78) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $80=$2; + var $81=$80; + var $82=(($81)|0); + var $83=$2; + var $84=(($83+24)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=(($82)|0); + var $87=HEAP32[(($86)>>2)]; + var $88=(($82+4)|0); + var $89=HEAP32[(($88)>>2)]; + _asterror($87, $89, ((STRING_TABLE.__str10)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$85,tempInt)); + $1=0; + __label__ = 29; break; + case 18: + var $91=$irf; + var $92=_ir_function_create_block($91, ((STRING_TABLE.__str11)|0)); + var $93=$2; + var $94=(($93+36)|0); + HEAP32[(($94)>>2)]=$92; + var $95=$2; + var $96=(($95+36)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($97)|0)!=0; + if ($98) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + var $100=$2; + var $101=$100; + var $102=(($101)|0); + var $103=$2; + var $104=(($103+24)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=(($102)|0); + var $107=HEAP32[(($106)>>2)]; + var $108=(($102+4)|0); + var $109=HEAP32[(($108)>>2)]; + _asterror($107, $109, ((STRING_TABLE.__str12)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$105,tempInt)); + $1=0; + __label__ = 29; break; + case 20: + $i=0; + __label__ = 21; break; + case 21: + var $112=$i; + var $113=$2; + var $114=(($113+120)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=(($112)>>>0) < (($115)>>>0); + if ($116) { __label__ = 22; break; } else { __label__ = 26; break; } + case 22: + var $118=$i; + var $119=$2; + var $120=(($119+116)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=(($121+($118<<2))|0); + var $123=HEAP32[(($122)>>2)]; + var $124=(($123)|0); + var $125=(($124+20)|0); + var $126=HEAP32[(($125)>>2)]; + $gen=$126; + var $127=$gen; + var $128=$i; + var $129=$2; + var $130=(($129+116)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=(($131+($128<<2))|0); + var $133=HEAP32[(($132)>>2)]; + var $134=$133; + var $135=$2; + var $136=FUNCTION_TABLE[$127]($134, $135, 0, $dummy); + if ($136) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + $1=0; + __label__ = 29; break; + case 24: + __label__ = 25; break; + case 25: + var $140=$i; + var $141=((($140)+(1))|0); + $i=$141; + __label__ = 21; break; + case 26: + var $143=$2; + var $144=(($143+36)|0); + var $145=HEAP32[(($144)>>2)]; + var $146=(($145+68)|0); + var $147=HEAP8[($146)]; + var $148=(($147) & 1); + if ($148) { __label__ = 28; break; } else { __label__ = 27; break; } + case 27: + var $150=$2; + var $151=(($150+36)|0); + var $152=HEAP32[(($151)>>2)]; + var $153=_ir_block_create_return($152, 0); + $1=$153; + __label__ = 29; break; + case 28: + $1=1; + __label__ = 29; break; + case 29: + var $156=$1; + STACKTOP = __stackBase__; + return $156; + default: assert(0, "bad label: " + __label__); + } +} +_ast_function_codegen["X"]=1; + +function _code_statements_add($element) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $element; $element = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($element)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($element)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $temp; + $temp=0; + var $2=HEAP32[((_code_statements_elements)>>2)]; + var $3=HEAP32[((_code_statements_allocated)>>2)]; + var $4=(($2)|0)==(($3)|0); + if ($4) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $6=HEAP32[((_code_statements_allocated)>>2)]; + var $7=(($6)|0)==0; + if ($7) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_statements_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $10=HEAP32[((_code_statements_allocated)>>2)]; + var $11=((($10<<1))|0); + HEAP32[((_code_statements_allocated)>>2)]=$11; + __label__ = 6; break; + case 6: + var $13=HEAP32[((_code_statements_allocated)>>2)]; + var $14=((($13<<3))|0); + var $15=_util_memory_a($14, 59, ((STRING_TABLE.__str112)|0)); + $temp=$15; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $18=$temp; + _util_memory_d($18, 59, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $20=$temp; + var $21=HEAP32[((_code_statements_data)>>2)]; + var $22=$21; + var $23=HEAP32[((_code_statements_elements)>>2)]; + var $24=((($23<<3))|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($20, $22, $24, 1); + var $25=HEAP32[((_code_statements_data)>>2)]; + var $26=$25; + _util_memory_d($26, 59, ((STRING_TABLE.__str112)|0)); + var $27=$temp; + var $28=$27; + HEAP32[((_code_statements_data)>>2)]=$28; + __label__ = 9; break; + case 9: + var $30=HEAP32[((_code_statements_elements)>>2)]; + var $31=HEAP32[((_code_statements_data)>>2)]; + var $32=(($31+($30<<3))|0); + var $33=$32; + var $34=$element; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP16[(($33)>>1)]=HEAP16[(($34)>>1)];HEAP16[((($33)+(2))>>1)]=HEAP16[((($34)+(2))>>1)];HEAP16[((($33)+(4))>>1)]=HEAP16[((($34)+(4))>>1)];HEAP16[((($33)+(6))>>1)]=HEAP16[((($34)+(6))>>1)]; + var $35=HEAP32[((_code_statements_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_code_statements_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + STACKTOP = __stackBase__; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_code_statements_add["X"]=1; + +function _code_defs_add($element) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $element; $element = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($element)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($element)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $temp; + $temp=0; + var $2=HEAP32[((_code_defs_elements)>>2)]; + var $3=HEAP32[((_code_defs_allocated)>>2)]; + var $4=(($2)|0)==(($3)|0); + if ($4) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $6=HEAP32[((_code_defs_allocated)>>2)]; + var $7=(($6)|0)==0; + if ($7) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_defs_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $10=HEAP32[((_code_defs_allocated)>>2)]; + var $11=((($10<<1))|0); + HEAP32[((_code_defs_allocated)>>2)]=$11; + __label__ = 6; break; + case 6: + var $13=HEAP32[((_code_defs_allocated)>>2)]; + var $14=((($13<<3))|0); + var $15=_util_memory_a($14, 60, ((STRING_TABLE.__str112)|0)); + $temp=$15; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $18=$temp; + _util_memory_d($18, 60, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $20=$temp; + var $21=HEAP32[((_code_defs_data)>>2)]; + var $22=$21; + var $23=HEAP32[((_code_defs_elements)>>2)]; + var $24=((($23<<3))|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($20, $22, $24, 1); + var $25=HEAP32[((_code_defs_data)>>2)]; + var $26=$25; + _util_memory_d($26, 60, ((STRING_TABLE.__str112)|0)); + var $27=$temp; + var $28=$27; + HEAP32[((_code_defs_data)>>2)]=$28; + __label__ = 9; break; + case 9: + var $30=HEAP32[((_code_defs_elements)>>2)]; + var $31=HEAP32[((_code_defs_data)>>2)]; + var $32=(($31+($30<<3))|0); + var $33=$32; + var $34=$element; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($33)>>2)]=HEAP32[(($34)>>2)];HEAP32[((($33)+(4))>>2)]=HEAP32[((($34)+(4))>>2)]; + var $35=HEAP32[((_code_defs_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_code_defs_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + STACKTOP = __stackBase__; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_code_defs_add["X"]=1; + +function _code_fields_add($element) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $element; $element = STACKTOP;STACKTOP += 8;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($element)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($element)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $temp; + $temp=0; + var $2=HEAP32[((_code_fields_elements)>>2)]; + var $3=HEAP32[((_code_fields_allocated)>>2)]; + var $4=(($2)|0)==(($3)|0); + if ($4) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $6=HEAP32[((_code_fields_allocated)>>2)]; + var $7=(($6)|0)==0; + if ($7) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_fields_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $10=HEAP32[((_code_fields_allocated)>>2)]; + var $11=((($10<<1))|0); + HEAP32[((_code_fields_allocated)>>2)]=$11; + __label__ = 6; break; + case 6: + var $13=HEAP32[((_code_fields_allocated)>>2)]; + var $14=((($13<<3))|0); + var $15=_util_memory_a($14, 61, ((STRING_TABLE.__str112)|0)); + $temp=$15; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $18=$temp; + _util_memory_d($18, 61, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $20=$temp; + var $21=HEAP32[((_code_fields_data)>>2)]; + var $22=$21; + var $23=HEAP32[((_code_fields_elements)>>2)]; + var $24=((($23<<3))|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($20, $22, $24, 1); + var $25=HEAP32[((_code_fields_data)>>2)]; + var $26=$25; + _util_memory_d($26, 61, ((STRING_TABLE.__str112)|0)); + var $27=$temp; + var $28=$27; + HEAP32[((_code_fields_data)>>2)]=$28; + __label__ = 9; break; + case 9: + var $30=HEAP32[((_code_fields_elements)>>2)]; + var $31=HEAP32[((_code_fields_data)>>2)]; + var $32=(($31+($30<<3))|0); + var $33=$32; + var $34=$element; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($33)>>2)]=HEAP32[(($34)>>2)];HEAP32[((($33)+(4))>>2)]=HEAP32[((($34)+(4))>>2)]; + var $35=HEAP32[((_code_fields_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_code_fields_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + STACKTOP = __stackBase__; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_code_fields_add["X"]=1; + +function _code_functions_add($element) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $element; $element = STACKTOP;STACKTOP += 36;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");for (var $$src = tempParam>>2, $$dest = $element>>2, $$stop = $$src + 9; $$src < $$stop; $$src++, $$dest++) { + HEAP32[$$dest] = HEAP32[$$src] +}; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $temp; + $temp=0; + var $2=HEAP32[((_code_functions_elements)>>2)]; + var $3=HEAP32[((_code_functions_allocated)>>2)]; + var $4=(($2)|0)==(($3)|0); + if ($4) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $6=HEAP32[((_code_functions_allocated)>>2)]; + var $7=(($6)|0)==0; + if ($7) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_functions_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $10=HEAP32[((_code_functions_allocated)>>2)]; + var $11=((($10<<1))|0); + HEAP32[((_code_functions_allocated)>>2)]=$11; + __label__ = 6; break; + case 6: + var $13=HEAP32[((_code_functions_allocated)>>2)]; + var $14=((($13)*(36))|0); + var $15=_util_memory_a($14, 62, ((STRING_TABLE.__str112)|0)); + $temp=$15; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $18=$temp; + _util_memory_d($18, 62, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $20=$temp; + var $21=HEAP32[((_code_functions_data)>>2)]; + var $22=$21; + var $23=HEAP32[((_code_functions_elements)>>2)]; + var $24=((($23)*(36))|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($20, $22, $24, 1); + var $25=HEAP32[((_code_functions_data)>>2)]; + var $26=$25; + _util_memory_d($26, 62, ((STRING_TABLE.__str112)|0)); + var $27=$temp; + var $28=$27; + HEAP32[((_code_functions_data)>>2)]=$28; + __label__ = 9; break; + case 9: + var $30=HEAP32[((_code_functions_elements)>>2)]; + var $31=HEAP32[((_code_functions_data)>>2)]; + var $32=(($31+($30)*(36))|0); + var $33=$32; + var $34=$element; + assert(36 % 1 === 0, 'memcpy given ' + 36 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');for (var $$src = $34>>2, $$dest = $33>>2, $$stop = $$src + 9; $$src < $$stop; $$src++, $$dest++) { + HEAP32[$$dest] = HEAP32[$$src] + }; + var $35=HEAP32[((_code_functions_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_code_functions_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + STACKTOP = __stackBase__; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_code_functions_add["X"]=1; + +function _code_globals_add($element) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $temp; + $2=$element; + $temp=0; + var $3=HEAP32[((_code_globals_elements)>>2)]; + var $4=HEAP32[((_code_globals_allocated)>>2)]; + var $5=(($3)|0)==(($4)|0); + if ($5) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $7=HEAP32[((_code_globals_allocated)>>2)]; + var $8=(($7)|0)==0; + if ($8) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_globals_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $11=HEAP32[((_code_globals_allocated)>>2)]; + var $12=((($11<<1))|0); + HEAP32[((_code_globals_allocated)>>2)]=$12; + __label__ = 6; break; + case 6: + var $14=HEAP32[((_code_globals_allocated)>>2)]; + var $15=((($14<<2))|0); + var $16=_util_memory_a($15, 63, ((STRING_TABLE.__str112)|0)); + $temp=$16; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $19=$temp; + _util_memory_d($19, 63, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $21=$temp; + var $22=HEAP32[((_code_globals_data)>>2)]; + var $23=$22; + var $24=HEAP32[((_code_globals_elements)>>2)]; + var $25=((($24<<2))|0); + assert($25 % 1 === 0, 'memcpy given ' + $25 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($21, $23, $25, 1); + var $26=HEAP32[((_code_globals_data)>>2)]; + var $27=$26; + _util_memory_d($27, 63, ((STRING_TABLE.__str112)|0)); + var $28=$temp; + var $29=$28; + HEAP32[((_code_globals_data)>>2)]=$29; + __label__ = 9; break; + case 9: + var $31=$2; + var $32=HEAP32[((_code_globals_elements)>>2)]; + var $33=HEAP32[((_code_globals_data)>>2)]; + var $34=(($33+($32<<2))|0); + HEAP32[(($34)>>2)]=$31; + var $35=HEAP32[((_code_globals_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_code_globals_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + ; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_code_globals_add["X"]=1; + +function _code_chars_add($element) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $temp; + $2=$element; + $temp=0; + var $3=HEAP32[((_code_chars_elements)>>2)]; + var $4=HEAP32[((_code_chars_allocated)>>2)]; + var $5=(($3)|0)==(($4)|0); + if ($5) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $7=HEAP32[((_code_chars_allocated)>>2)]; + var $8=(($7)|0)==0; + if ($8) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_code_chars_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $11=HEAP32[((_code_chars_allocated)>>2)]; + var $12=((($11<<1))|0); + HEAP32[((_code_chars_allocated)>>2)]=$12; + __label__ = 6; break; + case 6: + var $14=HEAP32[((_code_chars_allocated)>>2)]; + var $15=(($14)|0); + var $16=_util_memory_a($15, 64, ((STRING_TABLE.__str112)|0)); + $temp=$16; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $19=$temp; + _util_memory_d($19, 64, ((STRING_TABLE.__str112)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $21=$temp; + var $22=HEAP32[((_code_chars_data)>>2)]; + var $23=HEAP32[((_code_chars_elements)>>2)]; + var $24=(($23)|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($21, $22, $24, 1); + var $25=HEAP32[((_code_chars_data)>>2)]; + _util_memory_d($25, 64, ((STRING_TABLE.__str112)|0)); + var $26=$temp; + HEAP32[((_code_chars_data)>>2)]=$26; + __label__ = 9; break; + case 9: + var $28=$2; + var $29=HEAP32[((_code_chars_elements)>>2)]; + var $30=HEAP32[((_code_chars_data)>>2)]; + var $31=(($30+$29)|0); + HEAP8[($31)]=$28; + var $32=HEAP32[((_code_chars_elements)>>2)]; + var $33=((($32)+(1))|0); + HEAP32[((_code_chars_elements)>>2)]=$33; + $1=$32; + __label__ = 10; break; + case 10: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} +_code_chars_add["X"]=1; + +function _code_init() { + var __stackBase__ = STACKTOP; STACKTOP += 52; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $empty_function=__stackBase__; + var $empty_statement=(__stackBase__)+(36); + var $empty_def=(__stackBase__)+(44); + var $i; + var $1=$empty_function; + for (var $$dest = $1>>2, $$stop = $$dest + 9; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $2=$empty_statement; + HEAP16[(($2)>>1)]=0; HEAP16[((($2)+(2))>>1)]=0; HEAP16[((($2)+(4))>>1)]=0; HEAP16[((($2)+(6))>>1)]=0; + var $3=$empty_def; + HEAP32[(($3)>>2)]=0; HEAP32[((($3)+(4))>>2)]=0; + $i=0; + HEAP32[((_code_entfields)>>2)]=0; + var $4=HEAP32[((((_opts_flags)|0))>>2)]; + var $5=$4 & 4; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + __label__ = 9; break; + case 4: + __label__ = 5; break; + case 5: + var $10=$i; + var $11=(($10)|0) < 28; + if ($11) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $13=_code_globals_add(0); + __label__ = 7; break; + case 7: + var $15=$i; + var $16=((($15)+(1))|0); + $i=$16; + __label__ = 5; break; + case 8: + var $18=_code_chars_add(0); + var $19=_code_functions_add($empty_function); + var $20=_code_statements_add($empty_statement); + var $21=_code_defs_add($empty_def); + var $22=_code_fields_add($empty_def); + __label__ = 9; break; + case 9: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _code_genstring($str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $off; + $1=$str; + var $2=HEAP32[((_code_chars_elements)>>2)]; + $off=$2; + __label__ = 3; break; + case 3: + var $4=$1; + var $5=HEAP8[($4)]; + var $6=(($5 << 24) >> 24)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $8=$1; + var $9=HEAP8[($8)]; + var $10=_code_chars_add($9); + var $11=$1; + var $12=(($11+1)|0); + $1=$12; + __label__ = 3; break; + case 5: + var $14=_code_chars_add(0); + var $15=$off; + ; + return $15; + default: assert(0, "bad label: " + __label__); + } +} + + +function __ast_node_destroy($self) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + $1=$self; + var $2=HEAP32[((_stderr)>>2)]; + var $3=_fprintf($2, ((STRING_TABLE.__str111)|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)); + _abort(); + throw "Reached an unreachable!" + STACKTOP = __stackBase__; + return; +} + + +function _code_write($filename) { + var __stackBase__ = STACKTOP; STACKTOP += 60; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $code_header=__stackBase__; + var $fp; + var $it; + var $j; + $2=$filename; + $fp=0; + $it=2; + var $3=HEAP32[((((_opts_flags)|0))>>2)]; + var $4=$3 & 4; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + __label__ = 4; break; + case 4: + var $8=(($code_header+8)|0); + var $9=(($8)|0); + HEAP32[(($9)>>2)]=60; + var $10=HEAP32[((_code_statements_elements)>>2)]; + var $11=(($code_header+8)|0); + var $12=(($11+4)|0); + HEAP32[(($12)>>2)]=$10; + var $13=(($code_header+8)|0); + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=HEAP32[((_code_statements_elements)>>2)]; + var $17=((($16<<3))|0); + var $18=((($15)+($17))|0); + var $19=(($code_header+16)|0); + var $20=(($19)|0); + HEAP32[(($20)>>2)]=$18; + var $21=HEAP32[((_code_defs_elements)>>2)]; + var $22=(($code_header+16)|0); + var $23=(($22+4)|0); + HEAP32[(($23)>>2)]=$21; + var $24=(($code_header+16)|0); + var $25=(($24)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=HEAP32[((_code_defs_elements)>>2)]; + var $28=((($27<<3))|0); + var $29=((($26)+($28))|0); + var $30=(($code_header+24)|0); + var $31=(($30)|0); + HEAP32[(($31)>>2)]=$29; + var $32=HEAP32[((_code_fields_elements)>>2)]; + var $33=(($code_header+24)|0); + var $34=(($33+4)|0); + HEAP32[(($34)>>2)]=$32; + var $35=(($code_header+24)|0); + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=HEAP32[((_code_fields_elements)>>2)]; + var $39=((($38<<3))|0); + var $40=((($37)+($39))|0); + var $41=(($code_header+32)|0); + var $42=(($41)|0); + HEAP32[(($42)>>2)]=$40; + var $43=HEAP32[((_code_functions_elements)>>2)]; + var $44=(($code_header+32)|0); + var $45=(($44+4)|0); + HEAP32[(($45)>>2)]=$43; + var $46=(($code_header+32)|0); + var $47=(($46)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=HEAP32[((_code_functions_elements)>>2)]; + var $50=((($49)*(36))|0); + var $51=((($48)+($50))|0); + var $52=(($code_header+48)|0); + var $53=(($52)|0); + HEAP32[(($53)>>2)]=$51; + var $54=HEAP32[((_code_globals_elements)>>2)]; + var $55=(($code_header+48)|0); + var $56=(($55+4)|0); + HEAP32[(($56)>>2)]=$54; + var $57=(($code_header+48)|0); + var $58=(($57)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=HEAP32[((_code_globals_elements)>>2)]; + var $61=((($60<<2))|0); + var $62=((($59)+($61))|0); + var $63=(($code_header+40)|0); + var $64=(($63)|0); + HEAP32[(($64)>>2)]=$62; + var $65=HEAP32[((_code_chars_elements)>>2)]; + var $66=(($code_header+40)|0); + var $67=(($66+4)|0); + HEAP32[(($67)>>2)]=$65; + var $68=(($code_header)|0); + HEAP32[(($68)>>2)]=6; + var $69=HEAP8[(_opts_forcecrc)]; + var $70=(($69) & 1); + if ($70) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $72=HEAP16[((_opts_forced_crc)>>1)]; + var $73=(($code_header+4)|0); + HEAP16[(($73)>>1)]=$72; + __label__ = 7; break; + case 6: + var $75=HEAP16[((_code_crc)>>1)]; + var $76=(($code_header+4)|0); + HEAP16[(($76)>>1)]=$75; + __label__ = 7; break; + case 7: + var $78=HEAP32[((_code_entfields)>>2)]; + var $79=(($code_header+56)|0); + HEAP32[(($79)>>2)]=$78; + var $80=HEAP32[((((_opts_flags)|0))>>2)]; + var $81=$80 & 2; + var $82=(($81)|0)!=0; + if ($82) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str9121)|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)); + var $84=_code_chars_add(0); + var $85=_code_chars_add(0); + var $86=_code_chars_add(0); + __label__ = 9; break; + case 9: + var $88=$code_header; + _util_endianswap($88, 1, 60); + var $89=HEAP32[((_code_statements_data)>>2)]; + var $90=$89; + var $91=HEAP32[((_code_statements_elements)>>2)]; + _util_endianswap($90, $91, 8); + var $92=HEAP32[((_code_defs_data)>>2)]; + var $93=$92; + var $94=HEAP32[((_code_defs_elements)>>2)]; + _util_endianswap($93, $94, 8); + var $95=HEAP32[((_code_fields_data)>>2)]; + var $96=$95; + var $97=HEAP32[((_code_fields_elements)>>2)]; + _util_endianswap($96, $97, 8); + var $98=HEAP32[((_code_functions_data)>>2)]; + var $99=$98; + var $100=HEAP32[((_code_functions_elements)>>2)]; + _util_endianswap($99, $100, 36); + var $101=HEAP32[((_code_globals_data)>>2)]; + var $102=$101; + var $103=HEAP32[((_code_globals_elements)>>2)]; + _util_endianswap($102, $103, 4); + var $104=$2; + var $105=_util_fopen($104, ((STRING_TABLE.__str10122)|0)); + $fp=$105; + var $106=$fp; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 31; break; + case 11: + var $110=$code_header; + var $111=$fp; + var $112=_fwrite($110, 60, 1, $111); + var $113=1!=(($112)|0); + if ($113) { __label__ = 18; break; } else { __label__ = 12; break; } + case 12: + var $115=HEAP32[((_code_statements_elements)>>2)]; + var $116=HEAP32[((_code_statements_data)>>2)]; + var $117=$116; + var $118=HEAP32[((_code_statements_elements)>>2)]; + var $119=$fp; + var $120=_fwrite($117, 8, $118, $119); + var $121=(($115)|0)!=(($120)|0); + if ($121) { __label__ = 18; break; } else { __label__ = 13; break; } + case 13: + var $123=HEAP32[((_code_defs_elements)>>2)]; + var $124=HEAP32[((_code_defs_data)>>2)]; + var $125=$124; + var $126=HEAP32[((_code_defs_elements)>>2)]; + var $127=$fp; + var $128=_fwrite($125, 8, $126, $127); + var $129=(($123)|0)!=(($128)|0); + if ($129) { __label__ = 18; break; } else { __label__ = 14; break; } + case 14: + var $131=HEAP32[((_code_fields_elements)>>2)]; + var $132=HEAP32[((_code_fields_data)>>2)]; + var $133=$132; + var $134=HEAP32[((_code_fields_elements)>>2)]; + var $135=$fp; + var $136=_fwrite($133, 8, $134, $135); + var $137=(($131)|0)!=(($136)|0); + if ($137) { __label__ = 18; break; } else { __label__ = 15; break; } + case 15: + var $139=HEAP32[((_code_functions_elements)>>2)]; + var $140=HEAP32[((_code_functions_data)>>2)]; + var $141=$140; + var $142=HEAP32[((_code_functions_elements)>>2)]; + var $143=$fp; + var $144=_fwrite($141, 36, $142, $143); + var $145=(($139)|0)!=(($144)|0); + if ($145) { __label__ = 18; break; } else { __label__ = 16; break; } + case 16: + var $147=HEAP32[((_code_globals_elements)>>2)]; + var $148=HEAP32[((_code_globals_data)>>2)]; + var $149=$148; + var $150=HEAP32[((_code_globals_elements)>>2)]; + var $151=$fp; + var $152=_fwrite($149, 4, $150, $151); + var $153=(($147)|0)!=(($152)|0); + if ($153) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $155=HEAP32[((_code_chars_elements)>>2)]; + var $156=HEAP32[((_code_chars_data)>>2)]; + var $157=HEAP32[((_code_chars_elements)>>2)]; + var $158=$fp; + var $159=_fwrite($156, 1, $157, $158); + var $160=(($155)|0)!=(($159)|0); + if ($160) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + var $162=$fp; + var $163=_fclose($162); + $1=0; + __label__ = 31; break; + case 19: + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str11123)|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)); + var $165=(($code_header)|0); + var $166=HEAP32[(($165)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str12124)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$166,tempInt)); + var $167=(($code_header+4)|0); + var $168=HEAP16[(($167)>>1)]; + var $169=(($168)&65535); + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str13125)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$169,tempInt)); + var $170=(($code_header+56)|0); + var $171=HEAP32[(($170)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str14126)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$171,tempInt)); + var $172=(($code_header+8)|0); + var $173=(($172)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=(($code_header+8)|0); + var $176=(($175+4)|0); + var $177=HEAP32[(($176)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str15127)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$174,HEAP32[(((tempInt)+(4))>>2)]=$177,tempInt)); + var $178=(($code_header+16)|0); + var $179=(($178)|0); + var $180=HEAP32[(($179)>>2)]; + var $181=(($code_header+16)|0); + var $182=(($181+4)|0); + var $183=HEAP32[(($182)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str16128)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$180,HEAP32[(((tempInt)+(4))>>2)]=$183,tempInt)); + var $184=(($code_header+24)|0); + var $185=(($184)|0); + var $186=HEAP32[(($185)>>2)]; + var $187=(($code_header+24)|0); + var $188=(($187+4)|0); + var $189=HEAP32[(($188)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str17129)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$186,HEAP32[(((tempInt)+(4))>>2)]=$189,tempInt)); + var $190=(($code_header+32)|0); + var $191=(($190)|0); + var $192=HEAP32[(($191)>>2)]; + var $193=(($code_header+32)|0); + var $194=(($193+4)|0); + var $195=HEAP32[(($194)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str18130)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$192,HEAP32[(((tempInt)+(4))>>2)]=$195,tempInt)); + var $196=(($code_header+48)|0); + var $197=(($196)|0); + var $198=HEAP32[(($197)>>2)]; + var $199=(($code_header+48)|0); + var $200=(($199+4)|0); + var $201=HEAP32[(($200)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str19131)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$198,HEAP32[(((tempInt)+(4))>>2)]=$201,tempInt)); + var $202=(($code_header+40)|0); + var $203=(($202)|0); + var $204=HEAP32[(($203)>>2)]; + var $205=(($code_header+40)|0); + var $206=(($205+4)|0); + var $207=HEAP32[(($206)>>2)]; + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str20132)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$204,HEAP32[(((tempInt)+(4))>>2)]=$207,tempInt)); + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str21133)|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)); + __label__ = 20; break; + case 20: + var $209=$it; + var $210=HEAP32[((_code_functions_elements)>>2)]; + var $211=(($209)>>>0) < (($210)>>>0); + if ($211) { __label__ = 21; break; } else { __label__ = 30; break; } + case 21: + var $213=$it; + var $214=HEAP32[((_code_functions_data)>>2)]; + var $215=(($214+($213)*(36))|0); + var $216=(($215)|0); + var $217=HEAP32[(($216)>>2)]; + $j=$217; + var $218=$it; + var $219=HEAP32[((_code_functions_data)>>2)]; + var $220=(($219+($218)*(36))|0); + var $221=(($220)|0); + var $222=HEAP32[(($221)>>2)]; + var $223=$it; + var $224=HEAP32[((_code_functions_data)>>2)]; + var $225=(($224+($223)*(36))|0); + var $226=(($225+4)|0); + var $227=HEAP32[(($226)>>2)]; + var $228=$it; + var $229=HEAP32[((_code_functions_data)>>2)]; + var $230=(($229+($228)*(36))|0); + var $231=(($230+8)|0); + var $232=HEAP32[(($231)>>2)]; + var $233=$it; + var $234=HEAP32[((_code_functions_data)>>2)]; + var $235=(($234+($233)*(36))|0); + var $236=(($235+12)|0); + var $237=HEAP32[(($236)>>2)]; + var $238=$it; + var $239=HEAP32[((_code_functions_data)>>2)]; + var $240=(($239+($238)*(36))|0); + var $241=(($240+16)|0); + var $242=HEAP32[(($241)>>2)]; + var $243=$it; + var $244=HEAP32[((_code_functions_data)>>2)]; + var $245=(($244+($243)*(36))|0); + var $246=(($245+20)|0); + var $247=HEAP32[(($246)>>2)]; + var $248=$it; + var $249=HEAP32[((_code_functions_data)>>2)]; + var $250=(($249+($248)*(36))|0); + var $251=(($250+24)|0); + var $252=HEAP32[(($251)>>2)]; + var $253=$it; + var $254=HEAP32[((_code_functions_data)>>2)]; + var $255=(($254+($253)*(36))|0); + var $256=(($255+28)|0); + var $257=(($256)|0); + var $258=HEAP8[($257)]; + var $259=(($258)&255); + var $260=$it; + var $261=HEAP32[((_code_functions_data)>>2)]; + var $262=(($261+($260)*(36))|0); + var $263=(($262+28)|0); + var $264=(($263+1)|0); + var $265=HEAP8[($264)]; + var $266=(($265)&255); + var $267=$it; + var $268=HEAP32[((_code_functions_data)>>2)]; + var $269=(($268+($267)*(36))|0); + var $270=(($269+28)|0); + var $271=(($270+2)|0); + var $272=HEAP8[($271)]; + var $273=(($272)&255); + var $274=$it; + var $275=HEAP32[((_code_functions_data)>>2)]; + var $276=(($275+($274)*(36))|0); + var $277=(($276+28)|0); + var $278=(($277+3)|0); + var $279=HEAP8[($278)]; + var $280=(($279)&255); + var $281=$it; + var $282=HEAP32[((_code_functions_data)>>2)]; + var $283=(($282+($281)*(36))|0); + var $284=(($283+28)|0); + var $285=(($284+4)|0); + var $286=HEAP8[($285)]; + var $287=(($286)&255); + var $288=$it; + var $289=HEAP32[((_code_functions_data)>>2)]; + var $290=(($289+($288)*(36))|0); + var $291=(($290+28)|0); + var $292=(($291+5)|0); + var $293=HEAP8[($292)]; + var $294=(($293)&255); + var $295=$it; + var $296=HEAP32[((_code_functions_data)>>2)]; + var $297=(($296+($295)*(36))|0); + var $298=(($297+28)|0); + var $299=(($298+6)|0); + var $300=HEAP8[($299)]; + var $301=(($300)&255); + var $302=$it; + var $303=HEAP32[((_code_functions_data)>>2)]; + var $304=(($303+($302)*(36))|0); + var $305=(($304+28)|0); + var $306=(($305+7)|0); + var $307=HEAP8[($306)]; + var $308=(($307)&255); + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str22134)|0), (tempInt=STACKTOP,STACKTOP += 60,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$222,HEAP32[(((tempInt)+(4))>>2)]=$227,HEAP32[(((tempInt)+(8))>>2)]=$232,HEAP32[(((tempInt)+(12))>>2)]=$237,HEAP32[(((tempInt)+(16))>>2)]=$242,HEAP32[(((tempInt)+(20))>>2)]=$247,HEAP32[(((tempInt)+(24))>>2)]=$252,HEAP32[(((tempInt)+(28))>>2)]=$259,HEAP32[(((tempInt)+(32))>>2)]=$266,HEAP32[(((tempInt)+(36))>>2)]=$273,HEAP32[(((tempInt)+(40))>>2)]=$280,HEAP32[(((tempInt)+(44))>>2)]=$287,HEAP32[(((tempInt)+(48))>>2)]=$294,HEAP32[(((tempInt)+(52))>>2)]=$301,HEAP32[(((tempInt)+(56))>>2)]=$308,tempInt)); + var $309=$it; + var $310=HEAP32[((_code_functions_data)>>2)]; + var $311=(($310+($309)*(36))|0); + var $312=(($311+16)|0); + var $313=HEAP32[(($312)>>2)]; + var $314=HEAP32[((_code_chars_data)>>2)]; + var $315=(($314+$313)|0); + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str23135)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$315,tempInt)); + var $316=$it; + var $317=HEAP32[((_code_functions_data)>>2)]; + var $318=(($317+($316)*(36))|0); + var $319=(($318)|0); + var $320=HEAP32[(($319)>>2)]; + var $321=(($320)|0) >= 0; + if ($321) { __label__ = 22; break; } else { __label__ = 28; break; } + case 22: + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str24136)|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)); + __label__ = 23; break; + case 23: + var $324=$j; + var $325=HEAP32[((_code_statements_data)>>2)]; + var $326=(($325+($324<<3))|0); + var $327=(($326)|0); + var $328=HEAP16[(($327)>>1)]; + var $329=(($328)&65535); + var $330=(($329)|0)!=66; + if ($330) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + var $332=$j; + var $333=HEAP32[((_code_statements_data)>>2)]; + var $334=(($333+($332<<3))|0); + var $335=(($334)|0); + var $336=HEAP16[(($335)>>1)]; + var $337=(($336)&65535); + var $338=((_asm_instr138+($337)*(12))|0); + var $339=(($338)|0); + var $340=HEAP32[(($339)>>2)]; + var $341=$j; + var $342=HEAP32[((_code_statements_data)>>2)]; + var $343=(($342+($341<<3))|0); + var $344=(($343+2)|0); + var $345=$344; + var $346=HEAP16[(($345)>>1)]; + var $347=(($346 << 16) >> 16); + var $348=$j; + var $349=HEAP32[((_code_statements_data)>>2)]; + var $350=(($349+($348<<3))|0); + var $351=(($350+4)|0); + var $352=$351; + var $353=HEAP16[(($352)>>1)]; + var $354=(($353 << 16) >> 16); + var $355=$j; + var $356=HEAP32[((_code_statements_data)>>2)]; + var $357=(($356+($355<<3))|0); + var $358=(($357+6)|0); + var $359=$358; + var $360=HEAP16[(($359)>>1)]; + var $361=(($360 << 16) >> 16); + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str25137)|0), (tempInt=STACKTOP,STACKTOP += 16,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$340,HEAP32[(((tempInt)+(4))>>2)]=$347,HEAP32[(((tempInt)+(8))>>2)]=$354,HEAP32[(((tempInt)+(12))>>2)]=$361,tempInt)); + __label__ = 26; break; + case 25: + _util_debug(((STRING_TABLE.__str8120)|0), ((STRING_TABLE.__str26139)|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)); + __label__ = 27; break; + case 26: + var $364=$j; + var $365=((($364)+(1))|0); + $j=$365; + __label__ = 23; break; + case 27: + __label__ = 28; break; + case 28: + __label__ = 29; break; + case 29: + var $369=$it; + var $370=((($369)+(1))|0); + $it=$370; + __label__ = 20; break; + case 30: + var $372=HEAP32[((_code_statements_data)>>2)]; + var $373=$372; + _util_memory_d($373, 283, ((STRING_TABLE.__str112)|0)); + var $374=HEAP32[((_code_defs_data)>>2)]; + var $375=$374; + _util_memory_d($375, 284, ((STRING_TABLE.__str112)|0)); + var $376=HEAP32[((_code_fields_data)>>2)]; + var $377=$376; + _util_memory_d($377, 285, ((STRING_TABLE.__str112)|0)); + var $378=HEAP32[((_code_functions_data)>>2)]; + var $379=$378; + _util_memory_d($379, 286, ((STRING_TABLE.__str112)|0)); + var $380=HEAP32[((_code_globals_data)>>2)]; + var $381=$380; + _util_memory_d($381, 287, ((STRING_TABLE.__str112)|0)); + var $382=HEAP32[((_code_chars_data)>>2)]; + _util_memory_d($382, 288, ((STRING_TABLE.__str112)|0)); + var $383=$fp; + var $384=_fclose($383); + $1=1; + __label__ = 31; break; + case 31: + var $386=$1; + STACKTOP = __stackBase__; + return $386; + default: assert(0, "bad label: " + __label__); + } +} +_code_write["X"]=1; + +function _vprintmsg($level, $name, $line, $msgtype, $msg, $ap) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + $1=$level; + $2=$name; + $3=$line; + $4=$msgtype; + $5=$msg; + $6=$ap; + var $7=HEAP32[((_stderr)>>2)]; + var $8=$2; + var $9=$3; + var $10=$1; + var $11=((_levelcolor+($10<<2))|0); + var $12=HEAP32[(($11)>>2)]; + var $13=$4; + var $14=_fprintf($7, ((STRING_TABLE.__str207)|0), (tempInt=STACKTOP,STACKTOP += 20,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=36,HEAP32[(((tempInt)+(4))>>2)]=$8,HEAP32[(((tempInt)+(8))>>2)]=$9,HEAP32[(((tempInt)+(12))>>2)]=$12,HEAP32[(((tempInt)+(16))>>2)]=$13,tempInt)); + var $15=HEAP32[((_stderr)>>2)]; + var $16=$5; + var $17=$6; + var $18=_vfprintf($15, $16, $17); + var $19=HEAP32[((_stderr)>>2)]; + var $20=_fprintf($19, ((STRING_TABLE.__str1208)|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)); + STACKTOP = __stackBase__; + return; +} + + +function _cvprintmsg($ctx_0, $ctx_1, $lvl, $msgtype, $msg, $ap) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $2; + var $3; + var $4; + var $5=(($ctx)|0); + HEAP32[(($5)>>2)]=$ctx_0; + var $6=(($ctx+4)|0); + HEAP32[(($6)>>2)]=$ctx_1; + $1=$lvl; + $2=$msgtype; + $3=$msg; + $4=$ap; + var $7=$1; + var $8=(($ctx)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($ctx+4)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=$2; + var $13=$3; + var $14=$4; + _vprintmsg($7, $9, $11, $12, $13, $14); + STACKTOP = __stackBase__; + return; +} + + +function _ir_value_vector_v_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+8)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+8)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+8)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+8)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+8)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 142, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+4)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 142, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+4)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_vector_v_add["X"]=1; + +function _ir_builder_new($modulename) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $self; + $2=$modulename; + var $3=_util_memory_a(68, 182, ((STRING_TABLE.__str9222)|0)); + var $4=$3; + $self=$4; + var $5=$self; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $9=$self; + var $10=(($9+4)|0); + HEAP32[(($10)>>2)]=0; + var $11=$self; + var $12=(($11+8)|0); + HEAP32[(($12)>>2)]=0; + var $13=$self; + var $14=(($13+12)|0); + HEAP32[(($14)>>2)]=0; + var $15=$self; + var $16=(($15+16)|0); + HEAP32[(($16)>>2)]=0; + var $17=$self; + var $18=(($17+20)|0); + HEAP32[(($18)>>2)]=0; + var $19=$self; + var $20=(($19+24)|0); + HEAP32[(($20)>>2)]=0; + var $21=$self; + var $22=(($21+28)|0); + HEAP32[(($22)>>2)]=0; + var $23=$self; + var $24=(($23+32)|0); + HEAP32[(($24)>>2)]=0; + var $25=$self; + var $26=(($25+36)|0); + HEAP32[(($26)>>2)]=0; + var $27=$self; + var $28=(($27+40)|0); + HEAP32[(($28)>>2)]=0; + var $29=$self; + var $30=(($29+44)|0); + HEAP32[(($30)>>2)]=0; + var $31=$self; + var $32=(($31+48)|0); + HEAP32[(($32)>>2)]=0; + var $33=$self; + var $34=(($33+52)|0); + HEAP32[(($34)>>2)]=0; + var $35=$self; + var $36=(($35+56)|0); + HEAP32[(($36)>>2)]=0; + var $37=$self; + var $38=(($37+60)|0); + HEAP32[(($38)>>2)]=0; + var $39=$self; + var $40=(($39+64)|0); + HEAP32[(($40)>>2)]=0; + var $41=$self; + var $42=(($41)|0); + HEAP32[(($42)>>2)]=0; + var $43=$self; + var $44=$2; + var $45=_ir_builder_set_name($43, $44); + if ($45) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $47=$self; + var $48=$47; + _util_memory_d($48, 194, ((STRING_TABLE.__str9222)|0)); + $1=0; + __label__ = 7; break; + case 6: + var $50=$self; + $1=$50; + __label__ = 7; break; + case 7: + var $52=$1; + ; + return $52; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_new["X"]=1; + +function _ir_builder_set_name($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$name; + var $3=$1; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + _util_memory_d($10, 231, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $12=$2; + var $13=_util_strdup($12); + var $14=$1; + var $15=(($14)|0); + HEAP32[(($15)>>2)]=$13; + var $16=$1; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=$20 ^ 1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_builder_globals_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+20)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+24)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+24)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+24)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+24)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 201, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+16)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+20)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+16)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 201, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+16)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+20)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+16)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_globals_add["X"]=1; + +function _ir_builder_fields_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+32)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+36)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+36)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+36)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+36)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+36)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 202, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+28)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+32)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+28)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 202, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+28)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+32)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+28)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_fields_add["X"]=1; + +function _ir_builder_functions_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+8)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+12)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+12)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+12)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+12)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 203, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+4)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+8)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+4)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 203, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+4)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+8)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+4)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_functions_add["X"]=1; + +function _ir_builder_filenames_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+44)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+48)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+48)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+48)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+48)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+48)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 204, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+40)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+44)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+40)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 204, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+40)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+44)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+40)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_filenames_add["X"]=1; + +function _ir_builder_filestrings_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+56)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+60)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+60)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+60)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+60)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 205, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+52)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+56)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+52)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 205, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+52)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+56)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+52)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_filestrings_add["X"]=1; + +function _ir_builder_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + _util_memory_d($4, 210, ((STRING_TABLE.__str9222)|0)); + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$1; + var $8=(($7+8)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)!=(($9)|0); + if ($10) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $12=$i; + var $13=$1; + var $14=(($13+4)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + _ir_function_delete_quick($17); + __label__ = 5; break; + case 5: + var $19=$i; + var $20=((($19)+(1))|0); + $i=$20; + __label__ = 3; break; + case 6: + var $22=$1; + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $27=$1; + var $28=(($27+4)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=$29; + _util_memory_d($30, 214, ((STRING_TABLE.__str9222)|0)); + __label__ = 8; break; + case 8: + var $32=$1; + var $33=(($32+4)|0); + HEAP32[(($33)>>2)]=0; + var $34=$1; + var $35=(($34+8)|0); + HEAP32[(($35)>>2)]=0; + var $36=$1; + var $37=(($36+12)|0); + HEAP32[(($37)>>2)]=0; + $i=0; + __label__ = 9; break; + case 9: + var $39=$i; + var $40=$1; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=(($39)|0)!=(($42)|0); + if ($43) { __label__ = 10; break; } else { __label__ = 12; break; } + case 10: + var $45=$i; + var $46=$1; + var $47=(($46+16)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48+($45<<2))|0); + var $50=HEAP32[(($49)>>2)]; + _ir_value_delete($50); + __label__ = 11; break; + case 11: + var $52=$i; + var $53=((($52)+(1))|0); + $i=$53; + __label__ = 9; break; + case 12: + var $55=$1; + var $56=(($55+16)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=(($57)|0)!=0; + if ($58) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $60=$1; + var $61=(($60+16)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=$62; + _util_memory_d($63, 218, ((STRING_TABLE.__str9222)|0)); + __label__ = 14; break; + case 14: + var $65=$1; + var $66=(($65+16)|0); + HEAP32[(($66)>>2)]=0; + var $67=$1; + var $68=(($67+20)|0); + HEAP32[(($68)>>2)]=0; + var $69=$1; + var $70=(($69+24)|0); + HEAP32[(($70)>>2)]=0; + $i=0; + __label__ = 15; break; + case 15: + var $72=$i; + var $73=$1; + var $74=(($73+32)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=(($72)|0)!=(($75)|0); + if ($76) { __label__ = 16; break; } else { __label__ = 18; break; } + case 16: + var $78=$i; + var $79=$1; + var $80=(($79+28)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81+($78<<2))|0); + var $83=HEAP32[(($82)>>2)]; + _ir_value_delete($83); + __label__ = 17; break; + case 17: + var $85=$i; + var $86=((($85)+(1))|0); + $i=$86; + __label__ = 15; break; + case 18: + var $88=$1; + var $89=(($88+28)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=(($90)|0)!=0; + if ($91) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $93=$1; + var $94=(($93+28)|0); + var $95=HEAP32[(($94)>>2)]; + var $96=$95; + _util_memory_d($96, 222, ((STRING_TABLE.__str9222)|0)); + __label__ = 20; break; + case 20: + var $98=$1; + var $99=(($98+28)|0); + HEAP32[(($99)>>2)]=0; + var $100=$1; + var $101=(($100+32)|0); + HEAP32[(($101)>>2)]=0; + var $102=$1; + var $103=(($102+36)|0); + HEAP32[(($103)>>2)]=0; + var $104=$1; + var $105=(($104+40)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $109=$1; + var $110=(($109+40)|0); + var $111=HEAP32[(($110)>>2)]; + var $112=$111; + _util_memory_d($112, 223, ((STRING_TABLE.__str9222)|0)); + __label__ = 22; break; + case 22: + var $114=$1; + var $115=(($114+40)|0); + HEAP32[(($115)>>2)]=0; + var $116=$1; + var $117=(($116+44)|0); + HEAP32[(($117)>>2)]=0; + var $118=$1; + var $119=(($118+48)|0); + HEAP32[(($119)>>2)]=0; + var $120=$1; + var $121=(($120+52)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=(($122)|0)!=0; + if ($123) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + var $125=$1; + var $126=(($125+52)|0); + var $127=HEAP32[(($126)>>2)]; + var $128=$127; + _util_memory_d($128, 224, ((STRING_TABLE.__str9222)|0)); + __label__ = 24; break; + case 24: + var $130=$1; + var $131=(($130+52)|0); + HEAP32[(($131)>>2)]=0; + var $132=$1; + var $133=(($132+56)|0); + HEAP32[(($133)>>2)]=0; + var $134=$1; + var $135=(($134+60)|0); + HEAP32[(($135)>>2)]=0; + var $136=$1; + var $137=$136; + _util_memory_d($137, 225, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_delete["X"]=1; + +function _ir_function_delete_quick($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + _util_memory_d($4, 389, ((STRING_TABLE.__str9222)|0)); + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$1; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)!=(($9)|0); + if ($10) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $12=$i; + var $13=$1; + var $14=(($13+20)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + _ir_block_delete_quick($17); + __label__ = 5; break; + case 5: + var $19=$i; + var $20=((($19)+(1))|0); + $i=$20; + __label__ = 3; break; + case 6: + var $22=$1; + var $23=(($22+20)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $27=$1; + var $28=(($27+20)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=$29; + _util_memory_d($30, 393, ((STRING_TABLE.__str9222)|0)); + __label__ = 8; break; + case 8: + var $32=$1; + var $33=(($32+20)|0); + HEAP32[(($33)>>2)]=0; + var $34=$1; + var $35=(($34+24)|0); + HEAP32[(($35)>>2)]=0; + var $36=$1; + var $37=(($36+28)|0); + HEAP32[(($37)>>2)]=0; + var $38=$1; + var $39=(($38+8)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40)|0)!=0; + if ($41) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $43=$1; + var $44=(($43+8)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$45; + _util_memory_d($46, 395, ((STRING_TABLE.__str9222)|0)); + __label__ = 10; break; + case 10: + var $48=$1; + var $49=(($48+8)|0); + HEAP32[(($49)>>2)]=0; + var $50=$1; + var $51=(($50+12)|0); + HEAP32[(($51)>>2)]=0; + var $52=$1; + var $53=(($52+16)|0); + HEAP32[(($53)>>2)]=0; + $i=0; + __label__ = 11; break; + case 11: + var $55=$i; + var $56=$1; + var $57=(($56+44)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($55)|0)!=(($58)|0); + if ($59) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $61=$i; + var $62=$1; + var $63=(($62+40)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($64+($61<<2))|0); + var $66=HEAP32[(($65)>>2)]; + _ir_value_delete($66); + __label__ = 13; break; + case 13: + var $68=$i; + var $69=((($68)+(1))|0); + $i=$69; + __label__ = 11; break; + case 14: + var $71=$1; + var $72=(($71+40)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=(($73)|0)!=0; + if ($74) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $76=$1; + var $77=(($76+40)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$78; + _util_memory_d($79, 399, ((STRING_TABLE.__str9222)|0)); + __label__ = 16; break; + case 16: + var $81=$1; + var $82=(($81+40)|0); + HEAP32[(($82)>>2)]=0; + var $83=$1; + var $84=(($83+44)|0); + HEAP32[(($84)>>2)]=0; + var $85=$1; + var $86=(($85+48)|0); + HEAP32[(($86)>>2)]=0; + $i=0; + __label__ = 17; break; + case 17: + var $88=$i; + var $89=$1; + var $90=(($89+56)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($88)|0)!=(($91)|0); + if ($92) { __label__ = 18; break; } else { __label__ = 20; break; } + case 18: + var $94=$i; + var $95=$1; + var $96=(($95+52)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($97+($94<<2))|0); + var $99=HEAP32[(($98)>>2)]; + _ir_value_delete($99); + __label__ = 19; break; + case 19: + var $101=$i; + var $102=((($101)+(1))|0); + $i=$102; + __label__ = 17; break; + case 20: + var $104=$1; + var $105=(($104+52)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $109=$1; + var $110=(($109+52)|0); + var $111=HEAP32[(($110)>>2)]; + var $112=$111; + _util_memory_d($112, 403, ((STRING_TABLE.__str9222)|0)); + __label__ = 22; break; + case 22: + var $114=$1; + var $115=(($114+52)|0); + HEAP32[(($115)>>2)]=0; + var $116=$1; + var $117=(($116+56)|0); + HEAP32[(($117)>>2)]=0; + var $118=$1; + var $119=(($118+60)|0); + HEAP32[(($119)>>2)]=0; + var $120=$1; + var $121=$120; + _util_memory_d($121, 407, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_delete_quick["X"]=1; + +function _ir_value_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 785, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $11=$1; + var $12=(($11+52)|0); + var $13=HEAP8[($12)]; + var $14=(($13) & 1); + if ($14) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $16=$1; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)==1; + if ($19) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $21=$1; + var $22=(($21+56)|0); + var $23=$22; + var $24=HEAP32[(($23)>>2)]; + _util_memory_d($24, 789, ((STRING_TABLE.__str9222)|0)); + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + $i=0; + __label__ = 9; break; + case 9: + var $28=$i; + var $29=(($28)>>>0) < 3; + if ($29) { __label__ = 10; break; } else { __label__ = 14; break; } + case 10: + var $31=$i; + var $32=$1; + var $33=(($32+84)|0); + var $34=(($33+($31<<2))|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)!=0; + if ($36) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $38=$i; + var $39=$1; + var $40=(($39+84)|0); + var $41=(($40+($38<<2))|0); + var $42=HEAP32[(($41)>>2)]; + _ir_value_delete($42); + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + var $45=$i; + var $46=((($45)+(1))|0); + $i=$46; + __label__ = 9; break; + case 14: + var $48=$1; + var $49=(($48+28)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($50)|0)!=0; + if ($51) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $53=$1; + var $54=(($53+28)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$55; + _util_memory_d($56, 795, ((STRING_TABLE.__str9222)|0)); + __label__ = 16; break; + case 16: + var $58=$1; + var $59=(($58+28)|0); + HEAP32[(($59)>>2)]=0; + var $60=$1; + var $61=(($60+32)|0); + HEAP32[(($61)>>2)]=0; + var $62=$1; + var $63=(($62+36)|0); + HEAP32[(($63)>>2)]=0; + var $64=$1; + var $65=(($64+40)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=(($66)|0)!=0; + if ($67) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $69=$1; + var $70=(($69+40)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$71; + _util_memory_d($72, 796, ((STRING_TABLE.__str9222)|0)); + __label__ = 18; break; + case 18: + var $74=$1; + var $75=(($74+40)|0); + HEAP32[(($75)>>2)]=0; + var $76=$1; + var $77=(($76+44)|0); + HEAP32[(($77)>>2)]=0; + var $78=$1; + var $79=(($78+48)|0); + HEAP32[(($79)>>2)]=0; + var $80=$1; + var $81=(($80+100)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=(($82)|0)!=0; + if ($83) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $85=$1; + var $86=(($85+100)|0); + var $87=HEAP32[(($86)>>2)]; + var $88=$87; + _util_memory_d($88, 797, ((STRING_TABLE.__str9222)|0)); + __label__ = 20; break; + case 20: + var $90=$1; + var $91=(($90+100)|0); + HEAP32[(($91)>>2)]=0; + var $92=$1; + var $93=(($92+104)|0); + HEAP32[(($93)>>2)]=0; + var $94=$1; + var $95=(($94+108)|0); + HEAP32[(($95)>>2)]=0; + var $96=$1; + var $97=$96; + _util_memory_d($97, 798, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_delete["X"]=1; + +function _ir_builder_get_function($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$self; + $3=$name; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+8)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$3; + var $12=$i; + var $13=$2; + var $14=(($13+4)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=_strcmp($11, $19); + var $21=(($20)|0)!=0; + if ($21) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $23=$i; + var $24=$2; + var $25=(($24+4)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<2))|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_builder_create_function($self, $name, $outtype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $fn; + $2=$self; + $3=$name; + $4=$outtype; + var $5=$2; + var $6=$3; + var $7=_ir_builder_get_function($5, $6); + $fn=$7; + var $8=$fn; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 10; break; + case 4: + var $12=$2; + var $13=$4; + var $14=_ir_function_new($12, $13); + $fn=$14; + var $15=$fn; + var $16=$3; + var $17=_ir_function_set_name($15, $16); + if ($17) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $19=$2; + var $20=$fn; + var $21=_ir_builder_functions_add($19, $20); + if ($21) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $23=$fn; + _ir_function_delete($23); + $1=0; + __label__ = 10; break; + case 7: + var $25=$2; + var $26=$fn; + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=_ir_builder_create_global($25, $28, 6); + var $30=$fn; + var $31=(($30+36)|0); + HEAP32[(($31)>>2)]=$29; + var $32=$fn; + var $33=(($32+36)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($34)|0)!=0; + if ($35) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $37=$fn; + _ir_function_delete($37); + $1=0; + __label__ = 10; break; + case 9: + var $39=$fn; + var $40=(($39+36)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=(($41+52)|0); + HEAP8[($42)]=1; + var $43=$4; + var $44=$fn; + var $45=(($44+36)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($46+24)|0); + HEAP32[(($47)>>2)]=$43; + var $48=$fn; + var $49=$fn; + var $50=(($49+36)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=(($51+56)|0); + var $53=$52; + HEAP32[(($53)>>2)]=$48; + var $54=$fn; + var $55=(($54+36)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+12)|0); + var $58=$fn; + var $59=(($58+76)|0); + var $60=$57; + var $61=$59; + 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)]; + var $62=$fn; + $1=$62; + __label__ = 10; break; + case 10: + var $64=$1; + ; + return $64; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_create_function["X"]=1; + +function _ir_function_new($owner, $outtype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $self; + $2=$owner; + $3=$outtype; + var $4=_util_memory_a(96, 344, ((STRING_TABLE.__str9222)|0)); + var $5=$4; + $self=$5; + var $6=$self; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $10=$self; + var $11=$10; + for (var $$dest = $11>>2, $$stop = $$dest + 24; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $12=$self; + var $13=(($12)|0); + HEAP32[(($13)>>2)]=0; + var $14=$self; + var $15=_ir_function_set_name($14, ((STRING_TABLE.__str10223)|0)); + if ($15) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $17=$self; + var $18=$17; + _util_memory_d($18, 353, ((STRING_TABLE.__str9222)|0)); + $1=0; + __label__ = 7; break; + case 6: + var $20=$2; + var $21=$self; + var $22=(($21+92)|0); + HEAP32[(($22)>>2)]=$20; + var $23=$self; + var $24=(($23+76)|0); + var $25=(($24)|0); + HEAP32[(($25)>>2)]=((STRING_TABLE.__str11224)|0); + var $26=$self; + var $27=(($26+76)|0); + var $28=(($27+4)|0); + HEAP32[(($28)>>2)]=0; + var $29=$3; + var $30=$self; + var $31=(($30+4)|0); + HEAP32[(($31)>>2)]=$29; + var $32=$self; + var $33=(($32+36)|0); + HEAP32[(($33)>>2)]=0; + var $34=$self; + var $35=(($34+32)|0); + HEAP32[(($35)>>2)]=0; + var $36=$self; + var $37=(($36+8)|0); + HEAP32[(($37)>>2)]=0; + var $38=$self; + var $39=(($38+12)|0); + HEAP32[(($39)>>2)]=0; + var $40=$self; + var $41=(($40+16)|0); + HEAP32[(($41)>>2)]=0; + var $42=$self; + var $43=(($42+20)|0); + HEAP32[(($43)>>2)]=0; + var $44=$self; + var $45=(($44+24)|0); + HEAP32[(($45)>>2)]=0; + var $46=$self; + var $47=(($46+28)|0); + HEAP32[(($47)>>2)]=0; + var $48=$self; + var $49=(($48+40)|0); + HEAP32[(($49)>>2)]=0; + var $50=$self; + var $51=(($50+44)|0); + HEAP32[(($51)>>2)]=0; + var $52=$self; + var $53=(($52+48)|0); + HEAP32[(($53)>>2)]=0; + var $54=$self; + var $55=(($54+52)|0); + HEAP32[(($55)>>2)]=0; + var $56=$self; + var $57=(($56+56)|0); + HEAP32[(($57)>>2)]=0; + var $58=$self; + var $59=(($58+60)|0); + HEAP32[(($59)>>2)]=0; + var $60=$self; + var $61=(($60+84)|0); + HEAP32[(($61)>>2)]=-1; + var $62=$self; + var $63=(($62+64)|0); + HEAP32[(($63)>>2)]=0; + var $64=$self; + var $65=(($64+88)|0); + HEAP32[(($65)>>2)]=0; + var $66=$self; + $1=$66; + __label__ = 7; break; + case 7: + var $68=$1; + ; + return $68; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_new["X"]=1; + +function _ir_function_set_name($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$name; + var $3=$1; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + _util_memory_d($10, 381, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $12=$2; + var $13=_util_strdup($12); + var $14=$1; + var $15=(($14)|0); + HEAP32[(($15)>>2)]=$13; + var $16=$1; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=$20 ^ 1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_function_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + _util_memory_d($4, 413, ((STRING_TABLE.__str9222)|0)); + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$1; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)!=(($9)|0); + if ($10) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $12=$i; + var $13=$1; + var $14=(($13+20)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + _ir_block_delete($17); + __label__ = 5; break; + case 5: + var $19=$i; + var $20=((($19)+(1))|0); + $i=$20; + __label__ = 3; break; + case 6: + var $22=$1; + var $23=(($22+20)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $27=$1; + var $28=(($27+20)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=$29; + _util_memory_d($30, 417, ((STRING_TABLE.__str9222)|0)); + __label__ = 8; break; + case 8: + var $32=$1; + var $33=(($32+20)|0); + HEAP32[(($33)>>2)]=0; + var $34=$1; + var $35=(($34+24)|0); + HEAP32[(($35)>>2)]=0; + var $36=$1; + var $37=(($36+28)|0); + HEAP32[(($37)>>2)]=0; + var $38=$1; + var $39=(($38+8)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40)|0)!=0; + if ($41) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $43=$1; + var $44=(($43+8)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$45; + _util_memory_d($46, 419, ((STRING_TABLE.__str9222)|0)); + __label__ = 10; break; + case 10: + var $48=$1; + var $49=(($48+8)|0); + HEAP32[(($49)>>2)]=0; + var $50=$1; + var $51=(($50+12)|0); + HEAP32[(($51)>>2)]=0; + var $52=$1; + var $53=(($52+16)|0); + HEAP32[(($53)>>2)]=0; + $i=0; + __label__ = 11; break; + case 11: + var $55=$i; + var $56=$1; + var $57=(($56+44)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($55)|0)!=(($58)|0); + if ($59) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $61=$i; + var $62=$1; + var $63=(($62+40)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($64+($61<<2))|0); + var $66=HEAP32[(($65)>>2)]; + _ir_value_delete($66); + __label__ = 13; break; + case 13: + var $68=$i; + var $69=((($68)+(1))|0); + $i=$69; + __label__ = 11; break; + case 14: + var $71=$1; + var $72=(($71+40)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=(($73)|0)!=0; + if ($74) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $76=$1; + var $77=(($76+40)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$78; + _util_memory_d($79, 423, ((STRING_TABLE.__str9222)|0)); + __label__ = 16; break; + case 16: + var $81=$1; + var $82=(($81+40)|0); + HEAP32[(($82)>>2)]=0; + var $83=$1; + var $84=(($83+44)|0); + HEAP32[(($84)>>2)]=0; + var $85=$1; + var $86=(($85+48)|0); + HEAP32[(($86)>>2)]=0; + $i=0; + __label__ = 17; break; + case 17: + var $88=$i; + var $89=$1; + var $90=(($89+56)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($88)|0)!=(($91)|0); + if ($92) { __label__ = 18; break; } else { __label__ = 20; break; } + case 18: + var $94=$i; + var $95=$1; + var $96=(($95+52)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($97+($94<<2))|0); + var $99=HEAP32[(($98)>>2)]; + _ir_value_delete($99); + __label__ = 19; break; + case 19: + var $101=$i; + var $102=((($101)+(1))|0); + $i=$102; + __label__ = 17; break; + case 20: + var $104=$1; + var $105=(($104+52)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $109=$1; + var $110=(($109+52)|0); + var $111=HEAP32[(($110)>>2)]; + var $112=$111; + _util_memory_d($112, 427, ((STRING_TABLE.__str9222)|0)); + __label__ = 22; break; + case 22: + var $114=$1; + var $115=(($114+52)|0); + HEAP32[(($115)>>2)]=0; + var $116=$1; + var $117=(($116+56)|0); + HEAP32[(($117)>>2)]=0; + var $118=$1; + var $119=(($118+60)|0); + HEAP32[(($119)>>2)]=0; + var $120=$1; + var $121=$120; + _util_memory_d($121, 431, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_delete["X"]=1; + +function _ir_builder_create_global($self, $name, $vtype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $ve; + $2=$self; + $3=$name; + $4=$vtype; + var $5=$3; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 7; break; } + case 3: + var $8=$3; + var $9=(($8)|0); + var $10=HEAP8[($9)]; + var $11=(($10 << 24) >> 24); + var $12=(($11)|0)!=35; + if ($12) { __label__ = 4; break; } else { __label__ = 7; break; } + case 4: + var $14=$2; + var $15=$3; + var $16=_ir_builder_get_global($14, $15); + $ve=$16; + var $17=$ve; + var $18=(($17)|0)!=0; + if ($18) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 10; break; + case 6: + __label__ = 7; break; + case 7: + var $22=$3; + var $23=$4; + var $24=_ir_value_var($22, 0, $23); + $ve=$24; + var $25=$2; + var $26=$ve; + var $27=_ir_builder_globals_add($25, $26); + if ($27) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $29=$ve; + _ir_value_delete($29); + $1=0; + __label__ = 10; break; + case 9: + var $31=$ve; + $1=$31; + __label__ = 10; break; + case 10: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_builder_get_global($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$self; + $3=$name; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+20)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+16)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<2))|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$3; + var $20=_strcmp($18, $19); + var $21=(($20)|0)!=0; + if ($21) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $23=$i; + var $24=$2; + var $25=(($24+16)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<2))|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_var($name, $storetype, $vtype) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $self; + $2=$name; + $3=$storetype; + $4=$vtype; + var $5=_util_memory_a(112, 693, ((STRING_TABLE.__str9222)|0)); + var $6=$5; + $self=$6; + var $7=$4; + var $8=$self; + var $9=(($8+4)|0); + HEAP32[(($9)>>2)]=$7; + var $10=$self; + var $11=(($10+20)|0); + HEAP32[(($11)>>2)]=0; + var $12=$self; + var $13=(($12+24)|0); + HEAP32[(($13)>>2)]=0; + var $14=$3; + var $15=$self; + var $16=(($15+8)|0); + HEAP32[(($16)>>2)]=$14; + var $17=$self; + var $18=(($17+28)|0); + HEAP32[(($18)>>2)]=0; + var $19=$self; + var $20=(($19+32)|0); + HEAP32[(($20)>>2)]=0; + var $21=$self; + var $22=(($21+36)|0); + HEAP32[(($22)>>2)]=0; + var $23=$self; + var $24=(($23+40)|0); + HEAP32[(($24)>>2)]=0; + var $25=$self; + var $26=(($25+44)|0); + HEAP32[(($26)>>2)]=0; + var $27=$self; + var $28=(($27+48)|0); + HEAP32[(($28)>>2)]=0; + var $29=$self; + var $30=(($29+52)|0); + HEAP8[($30)]=0; + var $31=$self; + var $32=(($31+12)|0); + var $33=(($32)|0); + HEAP32[(($33)>>2)]=((STRING_TABLE.__str11224)|0); + var $34=$self; + var $35=(($34+12)|0); + var $36=(($35+4)|0); + HEAP32[(($36)>>2)]=0; + var $37=$self; + var $38=(($37)|0); + HEAP32[(($38)>>2)]=0; + var $39=$2; + var $40=(($39)|0)!=0; + if ($40) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $42=$self; + var $43=$2; + var $44=_ir_value_set_name($42, $43); + if ($44) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $46=$self; + var $47=(($46+12)|0); + var $48=(($47)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($47+4)|0); + var $51=HEAP32[(($50)>>2)]; + _irerror($49, $51, ((STRING_TABLE.__str13226)|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)); + var $52=$self; + var $53=$52; + _util_memory_d($53, 706, ((STRING_TABLE.__str9222)|0)); + $1=0; + __label__ = 6; break; + case 5: + var $55=$self; + var $56=(($55+56)|0); + var $57=$56; + HEAP32[(($57)>>2)]=0; HEAP32[((($57)+(4))>>2)]=0; HEAP32[((($57)+(8))>>2)]=0; + var $58=$self; + var $59=(($58+68)|0); + var $60=$59; + HEAP32[(($60)>>2)]=0; HEAP32[((($60)+(4))>>2)]=0; HEAP32[((($60)+(8))>>2)]=0; HEAP32[((($60)+(12))>>2)]=0; + var $61=$self; + var $62=(($61+84)|0); + var $63=(($62)|0); + HEAP32[(($63)>>2)]=0; + var $64=$self; + var $65=(($64+84)|0); + var $66=(($65+4)|0); + HEAP32[(($66)>>2)]=0; + var $67=$self; + var $68=(($67+84)|0); + var $69=(($68+8)|0); + HEAP32[(($69)>>2)]=0; + var $70=$self; + var $71=(($70+96)|0); + HEAP32[(($71)>>2)]=0; + var $72=$self; + var $73=(($72+100)|0); + HEAP32[(($73)>>2)]=0; + var $74=$self; + var $75=(($74+104)|0); + HEAP32[(($75)>>2)]=0; + var $76=$self; + var $77=(($76+108)|0); + HEAP32[(($77)>>2)]=0; + var $78=$self; + $1=$78; + __label__ = 6; break; + case 6: + var $80=$1; + STACKTOP = __stackBase__; + return $80; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_var["X"]=1; + +function _ir_builder_get_field($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$self; + $3=$name; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+32)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+28)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<2))|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$3; + var $20=_strcmp($18, $19); + var $21=(($20)|0)!=0; + if ($21) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $23=$i; + var $24=$2; + var $25=(($24+28)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<2))|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_builder_create_field($self, $name, $vtype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $ve; + $2=$self; + $3=$name; + $4=$vtype; + var $5=$2; + var $6=$3; + var $7=_ir_builder_get_field($5, $6); + $ve=$7; + var $8=$ve; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $12=$3; + var $13=_ir_value_var($12, 0, 5); + $ve=$13; + var $14=$4; + var $15=$ve; + var $16=(($15+20)|0); + HEAP32[(($16)>>2)]=$14; + var $17=$2; + var $18=$ve; + var $19=_ir_builder_fields_add($17, $18); + if ($19) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $21=$ve; + _ir_value_delete($21); + $1=0; + __label__ = 7; break; + case 6: + var $23=$ve; + $1=$23; + __label__ = 7; break; + case 7: + var $25=$1; + ; + return $25; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_function_values_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+44)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+48)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+48)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+48)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+48)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+48)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 373, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+40)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+44)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+40)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 373, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+40)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+44)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+40)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_values_add["X"]=1; + +function _ir_function_blocks_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+24)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+24)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+20)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+20)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+24)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+24)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+24)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+28)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+24)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 374, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+20)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+24)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+20)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 374, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+20)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_blocks_remove["X"]=1; + +function _ir_function_blocks_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+24)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+28)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+28)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+28)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+28)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+28)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 374, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+20)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+24)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+20)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 374, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+20)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+24)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+20)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_blocks_add["X"]=1; + +function _ir_function_locals_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+56)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+60)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+60)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+60)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+60)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 375, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+52)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+56)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+52)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 375, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+52)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+56)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+52)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_locals_add["X"]=1; + +function _ir_function_params_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+12)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+16)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+16)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+16)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+16)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+16)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 376, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+8)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+12)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+8)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 376, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+8)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+12)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+8)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_params_add["X"]=1; + +function _ir_block_delete($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 558, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + $i=0; + __label__ = 5; break; + case 5: + var $12=$i; + var $13=$1; + var $14=(($13+20)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)|0)!=(($15)|0); + if ($16) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $18=$i; + var $19=$1; + var $20=(($19+16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21+($18<<2))|0); + var $23=HEAP32[(($22)>>2)]; + _ir_instr_delete($23); + __label__ = 7; break; + case 7: + var $25=$i; + var $26=((($25)+(1))|0); + $i=$26; + __label__ = 5; break; + case 8: + var $28=$1; + var $29=(($28+16)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $33=$1; + var $34=(($33+16)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$35; + _util_memory_d($36, 561, ((STRING_TABLE.__str9222)|0)); + __label__ = 10; break; + case 10: + var $38=$1; + var $39=(($38+16)|0); + HEAP32[(($39)>>2)]=0; + var $40=$1; + var $41=(($40+20)|0); + HEAP32[(($41)>>2)]=0; + var $42=$1; + var $43=(($42+24)|0); + HEAP32[(($43)>>2)]=0; + var $44=$1; + var $45=(($44+28)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($46)|0)!=0; + if ($47) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $49=$1; + var $50=(($49+28)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=$51; + _util_memory_d($52, 562, ((STRING_TABLE.__str9222)|0)); + __label__ = 12; break; + case 12: + var $54=$1; + var $55=(($54+28)|0); + HEAP32[(($55)>>2)]=0; + var $56=$1; + var $57=(($56+32)|0); + HEAP32[(($57)>>2)]=0; + var $58=$1; + var $59=(($58+36)|0); + HEAP32[(($59)>>2)]=0; + var $60=$1; + var $61=(($60+40)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)!=0; + if ($63) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $65=$1; + var $66=(($65+40)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + _util_memory_d($68, 563, ((STRING_TABLE.__str9222)|0)); + __label__ = 14; break; + case 14: + var $70=$1; + var $71=(($70+40)|0); + HEAP32[(($71)>>2)]=0; + var $72=$1; + var $73=(($72+44)|0); + HEAP32[(($73)>>2)]=0; + var $74=$1; + var $75=(($74+48)|0); + HEAP32[(($75)>>2)]=0; + var $76=$1; + var $77=(($76+52)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($78)|0)!=0; + if ($79) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $81=$1; + var $82=(($81+52)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=$83; + _util_memory_d($84, 564, ((STRING_TABLE.__str9222)|0)); + __label__ = 16; break; + case 16: + var $86=$1; + var $87=(($86+52)|0); + HEAP32[(($87)>>2)]=0; + var $88=$1; + var $89=(($88+56)|0); + HEAP32[(($89)>>2)]=0; + var $90=$1; + var $91=(($90+60)|0); + HEAP32[(($91)>>2)]=0; + var $92=$1; + var $93=$92; + _util_memory_d($93, 565, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_delete["X"]=1; + +function _ir_function_collect_value($self, $v) { + ; + var __label__; + + var $1; + var $2; + $1=$self; + $2=$v; + var $3=$1; + var $4=$2; + var $5=_ir_function_values_add($3, $4); + ; + return $5; +} + + +function _ir_function_create_block($self, $label) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $bn; + $2=$self; + $3=$label; + var $4=$2; + var $5=$3; + var $6=_ir_block_new($4, $5); + $bn=$6; + var $7=$bn; + var $8=(($7+4)|0); + var $9=$8; + var $10=$2; + var $11=(($10+76)|0); + var $12=$11; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($9)>>2)]=HEAP32[(($12)>>2)];HEAP32[((($9)+(4))>>2)]=HEAP32[((($12)+(4))>>2)]; + var $13=$2; + var $14=$bn; + var $15=_ir_function_blocks_add($13, $14); + if ($15) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $17=$bn; + _ir_block_delete($17); + $1=0; + __label__ = 5; break; + case 4: + var $19=$bn; + $1=$19; + __label__ = 5; break; + case 5: + var $21=$1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_new($owner, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $self; + $2=$owner; + $3=$name; + var $4=_util_memory_a(88, 509, ((STRING_TABLE.__str9222)|0)); + var $5=$4; + $self=$5; + var $6=$self; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 8; break; + case 4: + var $10=$self; + var $11=$10; + for (var $$dest = $11>>2, $$stop = $$dest + 22; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $12=$self; + var $13=(($12)|0); + HEAP32[(($13)>>2)]=0; + var $14=$3; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $17=$self; + var $18=$3; + var $19=_ir_block_set_label($17, $18); + if ($19) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $21=$self; + var $22=$21; + _util_memory_d($22, 517, ((STRING_TABLE.__str9222)|0)); + $1=0; + __label__ = 8; break; + case 7: + var $24=$2; + var $25=$self; + var $26=(($25+76)|0); + HEAP32[(($26)>>2)]=$24; + var $27=$self; + var $28=(($27+4)|0); + var $29=(($28)|0); + HEAP32[(($29)>>2)]=((STRING_TABLE.__str11224)|0); + var $30=$self; + var $31=(($30+4)|0); + var $32=(($31+4)|0); + HEAP32[(($32)>>2)]=0; + var $33=$self; + var $34=(($33+12)|0); + HEAP8[($34)]=0; + var $35=$self; + var $36=(($35+16)|0); + HEAP32[(($36)>>2)]=0; + var $37=$self; + var $38=(($37+20)|0); + HEAP32[(($38)>>2)]=0; + var $39=$self; + var $40=(($39+24)|0); + HEAP32[(($40)>>2)]=0; + var $41=$self; + var $42=(($41+28)|0); + HEAP32[(($42)>>2)]=0; + var $43=$self; + var $44=(($43+32)|0); + HEAP32[(($44)>>2)]=0; + var $45=$self; + var $46=(($45+36)|0); + HEAP32[(($46)>>2)]=0; + var $47=$self; + var $48=(($47+40)|0); + HEAP32[(($48)>>2)]=0; + var $49=$self; + var $50=(($49+44)|0); + HEAP32[(($50)>>2)]=0; + var $51=$self; + var $52=(($51+48)|0); + HEAP32[(($52)>>2)]=0; + var $53=$self; + var $54=(($53+64)|0); + HEAP32[(($54)>>2)]=0; + var $55=$self; + var $56=(($55+68)|0); + HEAP8[($56)]=0; + var $57=$self; + var $58=(($57+72)|0); + HEAP32[(($58)>>2)]=0; + var $59=$self; + var $60=(($59+52)|0); + HEAP32[(($60)>>2)]=0; + var $61=$self; + var $62=(($61+56)|0); + HEAP32[(($62)>>2)]=0; + var $63=$self; + var $64=(($63+60)|0); + HEAP32[(($64)>>2)]=0; + var $65=$self; + var $66=(($65+80)|0); + HEAP8[($66)]=0; + var $67=$self; + $1=$67; + __label__ = 8; break; + case 8: + var $69=$1; + ; + return $69; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_new["X"]=1; + +function _ir_function_finalize($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$self; + var $3=$2; + var $4=(($3+32)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 11; break; + case 4: + var $9=$2; + var $10=_ir_function_naive_phi($9); + if ($10) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 11; break; + case 6: + var $13=$2; + _ir_function_enumerate($13); + var $14=$2; + var $15=_ir_function_calculate_liferanges($14); + if ($15) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 11; break; + case 8: + var $18=$2; + var $19=_ir_function_allocate_locals($18); + if ($19) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 11; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $23=$1; + ; + return $23; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_function_naive_phi($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + $2=$self; + $i=0; + __label__ = 3; break; + case 3: + var $4=$i; + var $5=$2; + var $6=(($5+24)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) < (($7)>>>0); + if ($8) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $10=$i; + var $11=$2; + var $12=(($11+20)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + var $16=_ir_block_naive_phi($15); + if ($16) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $20=$i; + var $21=((($20)+(1))|0); + $i=$21; + __label__ = 3; break; + case 8: + $1=1; + __label__ = 9; break; + case 9: + var $24=$1; + ; + return $24; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_function_enumerate($self) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + var $instruction_id=__stackBase__; + $1=$self; + HEAP32[(($instruction_id)>>2)]=0; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=$1; + var $5=(($4+24)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) < (($6)>>>0); + if ($7) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $9=$i; + var $10=$i; + var $11=$1; + var $12=(($11+20)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+64)|0); + HEAP32[(($16)>>2)]=$9; + var $17=$i; + var $18=$1; + var $19=(($18+20)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20+($17<<2))|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22+72)|0); + HEAP32[(($23)>>2)]=0; + var $24=$i; + var $25=$1; + var $26=(($25+20)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27+($24<<2))|0); + var $29=HEAP32[(($28)>>2)]; + _ir_block_enumerate($29, $instruction_id); + __label__ = 5; break; + case 5: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 6: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_function_calculate_liferanges($self) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $changed=__stackBase__; + var $block; + var $v; + $2=$self; + __label__ = 3; break; + case 3: + var $4=$2; + var $5=(($4+88)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=((($6)+(1))|0); + HEAP32[(($5)>>2)]=$7; + HEAP8[($changed)]=0; + $i=0; + __label__ = 4; break; + case 4: + var $9=$i; + var $10=$2; + var $11=(($10+24)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($9)|0)!=(($12)|0); + if ($13) { __label__ = 5; break; } else { __label__ = 11; break; } + case 5: + var $15=$i; + var $16=$2; + var $17=(($16+20)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+($15<<2))|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20+68)|0); + var $22=HEAP8[($21)]; + var $23=(($22) & 1); + if ($23) { __label__ = 6; break; } else { __label__ = 9; break; } + case 6: + var $25=$i; + var $26=$2; + var $27=(($26+20)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28+($25<<2))|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+56)|0); + HEAP32[(($31)>>2)]=0; + var $32=$i; + var $33=$2; + var $34=(($33+20)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+($32<<2))|0); + var $37=HEAP32[(($36)>>2)]; + var $38=_ir_block_life_propagate($37, 0, $changed); + if ($38) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 25; break; + case 8: + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $43=$i; + var $44=((($43)+(1))|0); + $i=$44; + __label__ = 4; break; + case 11: + __label__ = 12; break; + case 12: + var $47=HEAP8[($changed)]; + var $48=(($47) & 1); + if ($48) { __label__ = 3; break; } else { __label__ = 13; break; } + case 13: + var $50=$2; + var $51=(($50+24)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($52)|0)!=0; + if ($53) { __label__ = 14; break; } else { __label__ = 24; break; } + case 14: + var $55=$2; + var $56=(($55+20)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=(($57)|0); + var $59=HEAP32[(($58)>>2)]; + $block=$59; + $i=0; + __label__ = 15; break; + case 15: + var $61=$i; + var $62=$block; + var $63=(($62+56)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($61)>>>0) < (($64)>>>0); + if ($65) { __label__ = 16; break; } else { __label__ = 23; break; } + case 16: + var $67=$i; + var $68=$block; + var $69=(($68+52)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($70+($67<<2))|0); + var $72=HEAP32[(($71)>>2)]; + $v=$72; + var $73=$v; + var $74=(($73+96)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=(($75)|0)!=0; + if ($76) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $78=$v; + var $79=(($78+8)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=(($80)|0)!=1; + if ($81) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + __label__ = 22; break; + case 19: + var $84=$v; + var $85=(($84+12)|0); + var $86=$v; + var $87=(($86)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=(($85)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=(($85+4)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=_irwarning($90, $92, 2, ((STRING_TABLE.__str20234)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$88,tempInt)); + if ($93) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + $1=0; + __label__ = 25; break; + case 21: + __label__ = 22; break; + case 22: + var $97=$i; + var $98=((($97)+(1))|0); + $i=$98; + __label__ = 15; break; + case 23: + __label__ = 24; break; + case 24: + $1=1; + __label__ = 25; break; + case 25: + var $102=$1; + STACKTOP = __stackBase__; + return $102; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_calculate_liferanges["X"]=1; + +function _ir_function_allocate_locals($self) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $a; + var $retval; + var $pos; + var $slot; + var $v; + var $alloc=__stackBase__; + $2=$self; + $retval=1; + var $3=$2; + var $4=(($3+56)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 5; break; } else { __label__ = 3; break; } + case 3: + var $8=$2; + var $9=(($8+44)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($10)|0)!=0; + if ($11) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=1; + __label__ = 61; break; + case 5: + var $14=(($alloc)|0); + HEAP32[(($14)>>2)]=0; + var $15=(($alloc+4)|0); + HEAP32[(($15)>>2)]=0; + var $16=(($alloc+8)|0); + HEAP32[(($16)>>2)]=0; + var $17=(($alloc+12)|0); + HEAP32[(($17)>>2)]=0; + var $18=(($alloc+16)|0); + HEAP32[(($18)>>2)]=0; + var $19=(($alloc+20)|0); + HEAP32[(($19)>>2)]=0; + var $20=(($alloc+24)|0); + HEAP32[(($20)>>2)]=0; + var $21=(($alloc+28)|0); + HEAP32[(($21)>>2)]=0; + var $22=(($alloc+32)|0); + HEAP32[(($22)>>2)]=0; + $i=0; + __label__ = 6; break; + case 6: + var $24=$i; + var $25=$2; + var $26=(($25+56)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($24)>>>0) < (($27)>>>0); + if ($28) { __label__ = 7; break; } else { __label__ = 11; break; } + case 7: + var $30=$i; + var $31=$2; + var $32=(($31+52)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33+($30<<2))|0); + var $35=HEAP32[(($34)>>2)]; + var $36=_function_allocator_alloc($alloc, $35); + if ($36) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + __label__ = 49; break; + case 9: + __label__ = 10; break; + case 10: + var $40=$i; + var $41=((($40)+(1))|0); + $i=$41; + __label__ = 6; break; + case 11: + $i=0; + __label__ = 12; break; + case 12: + var $44=$i; + var $45=$2; + var $46=(($45+44)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($44)>>>0) < (($47)>>>0); + if ($48) { __label__ = 13; break; } else { __label__ = 31; break; } + case 13: + var $50=$i; + var $51=$2; + var $52=(($51+40)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($53+($50<<2))|0); + var $55=HEAP32[(($54)>>2)]; + $v=$55; + var $56=$v; + var $57=(($56+104)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58)|0)!=0; + if ($59) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + __label__ = 30; break; + case 15: + $a=0; + __label__ = 16; break; + case 16: + var $63=$a; + var $64=(($alloc+4)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($63)>>>0) < (($65)>>>0); + if ($66) { __label__ = 17; break; } else { __label__ = 25; break; } + case 17: + var $68=$a; + var $69=(($alloc)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($70+($68<<2))|0); + var $72=HEAP32[(($71)>>2)]; + $slot=$72; + var $73=$v; + var $74=$slot; + var $75=_ir_values_overlap($73, $74); + if ($75) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + __label__ = 24; break; + case 19: + var $78=$slot; + var $79=$v; + var $80=_ir_value_life_merge_into($78, $79); + if ($80) { __label__ = 21; break; } else { __label__ = 20; break; } + case 20: + __label__ = 49; break; + case 21: + var $83=$a; + var $84=(($alloc+12)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=(($85+($83<<2))|0); + var $87=HEAP32[(($86)>>2)]; + var $88=$v; + var $89=(($88+4)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=((_type_sizeof+($90<<2))|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($87)>>>0) < (($92)>>>0); + if ($93) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $95=$v; + var $96=(($95+4)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=((_type_sizeof+($97<<2))|0); + var $99=HEAP32[(($98)>>2)]; + var $100=$a; + var $101=(($alloc+12)|0); + var $102=HEAP32[(($101)>>2)]; + var $103=(($102+($100<<2))|0); + HEAP32[(($103)>>2)]=$99; + __label__ = 23; break; + case 23: + var $105=$a; + var $106=$i; + var $107=$2; + var $108=(($107+40)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=(($109+($106<<2))|0); + var $111=HEAP32[(($110)>>2)]; + var $112=(($111+68)|0); + var $113=(($112+8)|0); + HEAP32[(($113)>>2)]=$105; + __label__ = 25; break; + case 24: + var $115=$a; + var $116=((($115)+(1))|0); + $a=$116; + __label__ = 16; break; + case 25: + var $118=$a; + var $119=(($alloc+4)|0); + var $120=HEAP32[(($119)>>2)]; + var $121=(($118)>>>0) >= (($120)>>>0); + if ($121) { __label__ = 26; break; } else { __label__ = 29; break; } + case 26: + var $123=(($alloc+4)|0); + var $124=HEAP32[(($123)>>2)]; + var $125=$i; + var $126=$2; + var $127=(($126+40)|0); + var $128=HEAP32[(($127)>>2)]; + var $129=(($128+($125<<2))|0); + var $130=HEAP32[(($129)>>2)]; + var $131=(($130+68)|0); + var $132=(($131+8)|0); + HEAP32[(($132)>>2)]=$124; + var $133=$v; + var $134=_function_allocator_alloc($alloc, $133); + if ($134) { __label__ = 28; break; } else { __label__ = 27; break; } + case 27: + __label__ = 49; break; + case 28: + __label__ = 29; break; + case 29: + __label__ = 30; break; + case 30: + var $139=$i; + var $140=((($139)+(1))|0); + $i=$140; + __label__ = 12; break; + case 31: + var $142=(($alloc+12)|0); + var $143=HEAP32[(($142)>>2)]; + var $144=(($143)|0)!=0; + if ($144) { __label__ = 33; break; } else { __label__ = 32; break; } + case 32: + __label__ = 50; break; + case 33: + var $147=_function_allocator_positions_add($alloc, 0); + if ($147) { __label__ = 35; break; } else { __label__ = 34; break; } + case 34: + __label__ = 49; break; + case 35: + var $150=(($alloc+16)|0); + var $151=HEAP32[(($150)>>2)]; + var $152=(($151)|0)!=0; + if ($152) { __label__ = 36; break; } else { __label__ = 37; break; } + case 36: + var $154=(($alloc+24)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=(($155)|0); + var $157=HEAP32[(($156)>>2)]; + var $158=(($alloc+12)|0); + var $159=HEAP32[(($158)>>2)]; + var $160=(($159)|0); + var $161=HEAP32[(($160)>>2)]; + var $162=((($157)+($161))|0); + $pos=$162; + __label__ = 38; break; + case 37: + $pos=0; + __label__ = 38; break; + case 38: + $i=1; + __label__ = 39; break; + case 39: + var $166=$i; + var $167=(($alloc+16)|0); + var $168=HEAP32[(($167)>>2)]; + var $169=(($166)>>>0) < (($168)>>>0); + if ($169) { __label__ = 40; break; } else { __label__ = 44; break; } + case 40: + var $171=$i; + var $172=((($171)-(1))|0); + var $173=(($alloc+24)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=(($174+($172<<2))|0); + var $176=HEAP32[(($175)>>2)]; + var $177=$i; + var $178=((($177)-(1))|0); + var $179=(($alloc+12)|0); + var $180=HEAP32[(($179)>>2)]; + var $181=(($180+($178<<2))|0); + var $182=HEAP32[(($181)>>2)]; + var $183=((($176)+($182))|0); + $pos=$183; + var $184=$pos; + var $185=_function_allocator_positions_add($alloc, $184); + if ($185) { __label__ = 42; break; } else { __label__ = 41; break; } + case 41: + __label__ = 49; break; + case 42: + __label__ = 43; break; + case 43: + var $189=$i; + var $190=((($189)+(1))|0); + $i=$190; + __label__ = 39; break; + case 44: + var $192=$pos; + var $193=(($alloc+16)|0); + var $194=HEAP32[(($193)>>2)]; + var $195=((($194)-(1))|0); + var $196=(($alloc+12)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=(($197+($195<<2))|0); + var $199=HEAP32[(($198)>>2)]; + var $200=((($192)+($199))|0); + var $201=$2; + var $202=(($201+64)|0); + HEAP32[(($202)>>2)]=$200; + $i=0; + __label__ = 45; break; + case 45: + var $204=$i; + var $205=$2; + var $206=(($205+44)|0); + var $207=HEAP32[(($206)>>2)]; + var $208=(($204)>>>0) < (($207)>>>0); + if ($208) { __label__ = 46; break; } else { __label__ = 48; break; } + case 46: + var $210=$i; + var $211=$2; + var $212=(($211+40)|0); + var $213=HEAP32[(($212)>>2)]; + var $214=(($213+($210<<2))|0); + var $215=HEAP32[(($214)>>2)]; + var $216=(($215+68)|0); + var $217=(($216+8)|0); + var $218=HEAP32[(($217)>>2)]; + var $219=(($alloc+24)|0); + var $220=HEAP32[(($219)>>2)]; + var $221=(($220+($218<<2))|0); + var $222=HEAP32[(($221)>>2)]; + var $223=$i; + var $224=$2; + var $225=(($224+40)|0); + var $226=HEAP32[(($225)>>2)]; + var $227=(($226+($223<<2))|0); + var $228=HEAP32[(($227)>>2)]; + var $229=(($228+68)|0); + var $230=(($229+8)|0); + HEAP32[(($230)>>2)]=$222; + __label__ = 47; break; + case 47: + var $232=$i; + var $233=((($232)+(1))|0); + $i=$233; + __label__ = 45; break; + case 48: + __label__ = 50; break; + case 49: + $retval=0; + __label__ = 50; break; + case 50: + $i=0; + __label__ = 51; break; + case 51: + var $238=$i; + var $239=(($alloc+4)|0); + var $240=HEAP32[(($239)>>2)]; + var $241=(($238)>>>0) < (($240)>>>0); + if ($241) { __label__ = 52; break; } else { __label__ = 54; break; } + case 52: + var $243=$i; + var $244=(($alloc)|0); + var $245=HEAP32[(($244)>>2)]; + var $246=(($245+($243<<2))|0); + var $247=HEAP32[(($246)>>2)]; + _ir_value_delete($247); + __label__ = 53; break; + case 53: + var $249=$i; + var $250=((($249)+(1))|0); + $i=$250; + __label__ = 51; break; + case 54: + var $252=(($alloc)|0); + var $253=HEAP32[(($252)>>2)]; + var $254=(($253)|0)!=0; + if ($254) { __label__ = 55; break; } else { __label__ = 56; break; } + case 55: + var $256=(($alloc)|0); + var $257=HEAP32[(($256)>>2)]; + var $258=$257; + _util_memory_d($258, 2043, ((STRING_TABLE.__str9222)|0)); + __label__ = 56; break; + case 56: + var $260=(($alloc)|0); + HEAP32[(($260)>>2)]=0; + var $261=(($alloc+4)|0); + HEAP32[(($261)>>2)]=0; + var $262=(($alloc+8)|0); + HEAP32[(($262)>>2)]=0; + var $263=(($alloc+12)|0); + var $264=HEAP32[(($263)>>2)]; + var $265=(($264)|0)!=0; + if ($265) { __label__ = 57; break; } else { __label__ = 58; break; } + case 57: + var $267=(($alloc+12)|0); + var $268=HEAP32[(($267)>>2)]; + var $269=$268; + _util_memory_d($269, 2044, ((STRING_TABLE.__str9222)|0)); + __label__ = 58; break; + case 58: + var $271=(($alloc+12)|0); + HEAP32[(($271)>>2)]=0; + var $272=(($alloc+16)|0); + HEAP32[(($272)>>2)]=0; + var $273=(($alloc+20)|0); + HEAP32[(($273)>>2)]=0; + var $274=(($alloc+24)|0); + var $275=HEAP32[(($274)>>2)]; + var $276=(($275)|0)!=0; + if ($276) { __label__ = 59; break; } else { __label__ = 60; break; } + case 59: + var $278=(($alloc+24)|0); + var $279=HEAP32[(($278)>>2)]; + var $280=$279; + _util_memory_d($280, 2045, ((STRING_TABLE.__str9222)|0)); + __label__ = 60; break; + case 60: + var $282=(($alloc+24)|0); + HEAP32[(($282)>>2)]=0; + var $283=(($alloc+28)|0); + HEAP32[(($283)>>2)]=0; + var $284=(($alloc+32)|0); + HEAP32[(($284)>>2)]=0; + var $285=$retval; + var $286=(($285) & 1); + $1=$286; + __label__ = 61; break; + case 61: + var $288=$1; + STACKTOP = __stackBase__; + return $288; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_allocate_locals["X"]=1; + +function _ir_function_create_local($self, $name, $vtype, $param) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $ve; + $2=$self; + $3=$name; + $4=$vtype; + var $6=(($param)&1); + $5=$6; + var $7=$5; + var $8=(($7) & 1); + if ($8) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $10=$2; + var $11=(($10+56)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $15=$2; + var $16=(($15+56)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=((($17)-(1))|0); + var $19=$2; + var $20=(($19+52)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21+($18<<2))|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+8)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)!=2; + if ($26) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $28=$2; + var $29=(($28+76)|0); + var $30=(($29)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($29+4)|0); + var $33=HEAP32[(($32)>>2)]; + _irerror($31, $33, ((STRING_TABLE.__str12225)|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)); + $1=0; + __label__ = 9; break; + case 6: + var $35=$3; + var $36=$5; + var $37=(($36) & 1); + var $38=$37 ? 2 : 1; + var $39=$4; + var $40=_ir_value_var($35, $38, $39); + $ve=$40; + var $41=$2; + var $42=$ve; + var $43=_ir_function_locals_add($41, $42); + if ($43) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $45=$ve; + _ir_value_delete($45); + $1=0; + __label__ = 9; break; + case 8: + var $47=$ve; + $1=$47; + __label__ = 9; break; + case 9: + var $49=$1; + STACKTOP = __stackBase__; + return $49; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_create_local["X"]=1; + +function _irerror($ctx_0, $ctx_1, $msg) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $ap=(__stackBase__)+(8); + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + $1=$msg; + var $4=$ap; + HEAP32[(($4)>>2)]=arguments[_irerror.length]; + var $5=$1; + var $6=HEAP32[(($ap)>>2)]; + var $7=(($ctx)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($ctx+4)|0); + var $10=HEAP32[(($9)>>2)]; + _cvprintmsg($8, $10, 2, ((STRING_TABLE.__str153)|0), $5, $6); + var $11=$ap; + ; + STACKTOP = __stackBase__; + return; +} + + +function _ir_block_set_label($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$name; + var $3=$1; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + _util_memory_d($10, 571, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $12=$2; + var $13=_util_strdup($12); + var $14=$1; + var $15=(($14)|0); + HEAP32[(($15)>>2)]=$13; + var $16=$1; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=$20 ^ 1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_instr_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+20)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+20)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+16)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+16)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+20)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+20)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+24)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+20)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 537, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+16)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+20)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+16)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 537, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+16)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_instr_remove["X"]=1; + +function _ir_block_instr_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+20)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+24)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+24)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+24)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+24)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 537, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+16)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+20)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+16)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 537, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+16)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+20)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+16)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_instr_add["X"]=1; + +function _ir_block_living_find($self, $obj, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + $2=$self; + $3=$obj; + $4=$idx; + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$2; + var $8=(($7+56)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)>>>0) < (($9)>>>0); + if ($10) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + var $12=$i; + var $13=$2; + var $14=(($13+52)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$3; + var $19=(($17)|0)==(($18)|0); + if ($19) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $21=$4; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $24=$i; + var $25=$4; + HEAP32[(($25)>>2)]=$24; + __label__ = 7; break; + case 7: + $1=1; + __label__ = 11; break; + case 8: + __label__ = 9; break; + case 9: + var $29=$i; + var $30=((($29)+(1))|0); + $i=$30; + __label__ = 3; break; + case 10: + $1=0; + __label__ = 11; break; + case 11: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_entries_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+32)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+36)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+36)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+36)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+36)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+36)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 538, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+28)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+32)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+28)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 538, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+28)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+32)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+28)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_entries_add["X"]=1; + +function _ir_block_exits_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+44)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+48)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+48)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+48)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+48)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+48)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 539, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+40)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+44)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+40)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 539, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+40)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+44)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+40)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_exits_add["X"]=1; + +function _ir_block_living_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+56)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+56)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+52)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+52)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+56)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+56)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+56)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+60)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+56)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 540, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+52)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+56)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+52)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 540, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+52)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_living_remove["X"]=1; + +function _ir_block_living_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+56)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+60)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+60)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+60)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+60)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 540, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+52)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+56)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+52)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 540, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+52)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+56)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+52)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_living_add["X"]=1; + +function _ir_instr_delete($self) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + var $idx=__stackBase__; + var $idx1=(__stackBase__)+(4); + $1=$self; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=$1; + var $5=(($4+36)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) < (($6)>>>0); + if ($7) { __label__ = 4; break; } else { __label__ = 18; break; } + case 4: + var $9=$i; + var $10=$1; + var $11=(($10+32)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12+($9<<3))|0); + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$1; + var $17=_ir_value_writes_find($15, $16, $idx); + if ($17) { __label__ = 5; break; } else { __label__ = 10; break; } + case 5: + var $19=$i; + var $20=$1; + var $21=(($20+32)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22+($19<<3))|0); + var $24=(($23)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=HEAP32[(($idx)>>2)]; + var $27=_ir_value_writes_remove($25, $26); + if ($27) { __label__ = 6; break; } else { __label__ = 9; break; } + case 6: + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $33=$i; + var $34=$1; + var $35=(($34+32)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36+($33<<3))|0); + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$1; + var $41=_ir_value_reads_find($39, $40, $idx); + if ($41) { __label__ = 11; break; } else { __label__ = 16; break; } + case 11: + var $43=$i; + var $44=$1; + var $45=(($44+32)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($46+($43<<3))|0); + var $48=(($47)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=HEAP32[(($idx)>>2)]; + var $51=_ir_value_reads_remove($49, $50); + if ($51) { __label__ = 12; break; } else { __label__ = 15; break; } + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + __label__ = 15; break; + case 15: + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + var $58=$i; + var $59=((($58)+(1))|0); + $i=$59; + __label__ = 3; break; + case 18: + var $61=$1; + var $62=(($61+32)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63)|0)!=0; + if ($64) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $66=$1; + var $67=(($66+32)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + _util_memory_d($69, 628, ((STRING_TABLE.__str9222)|0)); + __label__ = 20; break; + case 20: + var $71=$1; + var $72=(($71+32)|0); + HEAP32[(($72)>>2)]=0; + var $73=$1; + var $74=(($73+36)|0); + HEAP32[(($74)>>2)]=0; + var $75=$1; + var $76=(($75+40)|0); + HEAP32[(($76)>>2)]=0; + $i=0; + __label__ = 21; break; + case 21: + var $78=$i; + var $79=$1; + var $80=(($79+48)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($78)>>>0) < (($81)>>>0); + if ($82) { __label__ = 22; break; } else { __label__ = 36; break; } + case 22: + var $84=$i; + var $85=$1; + var $86=(($85+44)|0); + var $87=HEAP32[(($86)>>2)]; + var $88=(($87+($84<<2))|0); + var $89=HEAP32[(($88)>>2)]; + var $90=$1; + var $91=_ir_value_writes_find($89, $90, $idx1); + if ($91) { __label__ = 23; break; } else { __label__ = 28; break; } + case 23: + var $93=$i; + var $94=$1; + var $95=(($94+44)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=(($96+($93<<2))|0); + var $98=HEAP32[(($97)>>2)]; + var $99=HEAP32[(($idx1)>>2)]; + var $100=_ir_value_writes_remove($98, $99); + if ($100) { __label__ = 24; break; } else { __label__ = 27; break; } + case 24: + __label__ = 25; break; + case 25: + __label__ = 26; break; + case 26: + __label__ = 27; break; + case 27: + __label__ = 28; break; + case 28: + var $106=$i; + var $107=$1; + var $108=(($107+44)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=(($109+($106<<2))|0); + var $111=HEAP32[(($110)>>2)]; + var $112=$1; + var $113=_ir_value_reads_find($111, $112, $idx1); + if ($113) { __label__ = 29; break; } else { __label__ = 34; break; } + case 29: + var $115=$i; + var $116=$1; + var $117=(($116+44)|0); + var $118=HEAP32[(($117)>>2)]; + var $119=(($118+($115<<2))|0); + var $120=HEAP32[(($119)>>2)]; + var $121=HEAP32[(($idx1)>>2)]; + var $122=_ir_value_reads_remove($120, $121); + if ($122) { __label__ = 30; break; } else { __label__ = 33; break; } + case 30: + __label__ = 31; break; + case 31: + __label__ = 32; break; + case 32: + __label__ = 33; break; + case 33: + __label__ = 34; break; + case 34: + __label__ = 35; break; + case 35: + var $129=$i; + var $130=((($129)+(1))|0); + $i=$130; + __label__ = 21; break; + case 36: + var $132=$1; + var $133=(($132+44)|0); + var $134=HEAP32[(($133)>>2)]; + var $135=(($134)|0)!=0; + if ($135) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + var $137=$1; + var $138=(($137+44)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=$139; + _util_memory_d($140, 636, ((STRING_TABLE.__str9222)|0)); + __label__ = 38; break; + case 38: + var $142=$1; + var $143=(($142+44)|0); + HEAP32[(($143)>>2)]=0; + var $144=$1; + var $145=(($144+48)|0); + HEAP32[(($145)>>2)]=0; + var $146=$1; + var $147=(($146+52)|0); + HEAP32[(($147)>>2)]=0; + var $148=$1; + var $149=_ir_instr_op($148, 0, 0, 0); + if ($149) { __label__ = 39; break; } else { __label__ = 42; break; } + case 39: + __label__ = 40; break; + case 40: + __label__ = 41; break; + case 41: + __label__ = 42; break; + case 42: + var $154=$1; + var $155=_ir_instr_op($154, 1, 0, 0); + if ($155) { __label__ = 43; break; } else { __label__ = 46; break; } + case 43: + __label__ = 44; break; + case 44: + __label__ = 45; break; + case 45: + __label__ = 46; break; + case 46: + var $160=$1; + var $161=_ir_instr_op($160, 2, 0, 0); + if ($161) { __label__ = 47; break; } else { __label__ = 50; break; } + case 47: + __label__ = 48; break; + case 48: + __label__ = 49; break; + case 49: + __label__ = 50; break; + case 50: + var $166=$1; + var $167=$166; + _util_memory_d($167, 640, ((STRING_TABLE.__str9222)|0)); + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_delete["X"]=1; + +function _ir_instr_new($owner, $op) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $self; + $2=$owner; + $3=$op; + var $4=_util_memory_a(64, 583, ((STRING_TABLE.__str9222)|0)); + var $5=$4; + $self=$5; + var $6=$self; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $10=$2; + var $11=$self; + var $12=(($11+60)|0); + HEAP32[(($12)>>2)]=$10; + var $13=$self; + var $14=(($13+4)|0); + var $15=(($14)|0); + HEAP32[(($15)>>2)]=((STRING_TABLE.__str11224)|0); + var $16=$self; + var $17=(($16+4)|0); + var $18=(($17+4)|0); + HEAP32[(($18)>>2)]=0; + var $19=$3; + var $20=$self; + var $21=(($20)|0); + HEAP32[(($21)>>2)]=$19; + var $22=$self; + var $23=(($22+12)|0); + var $24=(($23)|0); + HEAP32[(($24)>>2)]=0; + var $25=$self; + var $26=(($25+12)|0); + var $27=(($26+4)|0); + HEAP32[(($27)>>2)]=0; + var $28=$self; + var $29=(($28+12)|0); + var $30=(($29+8)|0); + HEAP32[(($30)>>2)]=0; + var $31=$self; + var $32=(($31+24)|0); + var $33=(($32)|0); + HEAP32[(($33)>>2)]=0; + var $34=$self; + var $35=(($34+24)|0); + var $36=(($35+4)|0); + HEAP32[(($36)>>2)]=0; + var $37=$self; + var $38=(($37+32)|0); + HEAP32[(($38)>>2)]=0; + var $39=$self; + var $40=(($39+36)|0); + HEAP32[(($40)>>2)]=0; + var $41=$self; + var $42=(($41+40)|0); + HEAP32[(($42)>>2)]=0; + var $43=$self; + var $44=(($43+44)|0); + HEAP32[(($44)>>2)]=0; + var $45=$self; + var $46=(($45+48)|0); + HEAP32[(($46)>>2)]=0; + var $47=$self; + var $48=(($47+52)|0); + HEAP32[(($48)>>2)]=0; + var $49=$self; + var $50=(($49+56)|0); + HEAP32[(($50)>>2)]=0; + var $51=$self; + $1=$51; + __label__ = 5; break; + case 5: + var $53=$1; + ; + return $53; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_new["X"]=1; + +function _ir_instr_params_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+48)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+48)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+44)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+44)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+48)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+48)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+48)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+52)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+48)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 603, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+44)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+48)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+44)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 603, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+44)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_params_remove["X"]=1; + +function _ir_value_writes_find($self, $obj, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + $2=$self; + $3=$obj; + $4=$idx; + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$2; + var $8=(($7+44)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)>>>0) < (($9)>>>0); + if ($10) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + var $12=$i; + var $13=$2; + var $14=(($13+40)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$3; + var $19=(($17)|0)==(($18)|0); + if ($19) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $21=$4; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $24=$i; + var $25=$4; + HEAP32[(($25)>>2)]=$24; + __label__ = 7; break; + case 7: + $1=1; + __label__ = 11; break; + case 8: + __label__ = 9; break; + case 9: + var $29=$i; + var $30=((($29)+(1))|0); + $i=$30; + __label__ = 3; break; + case 10: + $1=0; + __label__ = 11; break; + case 11: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_reads_find($self, $obj, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + $2=$self; + $3=$obj; + $4=$idx; + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$2; + var $8=(($7+32)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)>>>0) < (($9)>>>0); + if ($10) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + var $12=$i; + var $13=$2; + var $14=(($13+28)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$3; + var $19=(($17)|0)==(($18)|0); + if ($19) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $21=$4; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $24=$i; + var $25=$4; + HEAP32[(($25)>>2)]=$24; + __label__ = 7; break; + case 7: + $1=1; + __label__ = 11; break; + case 8: + __label__ = 9; break; + case 9: + var $29=$i; + var $30=((($29)+(1))|0); + $i=$30; + __label__ = 3; break; + case 10: + $1=0; + __label__ = 11; break; + case 11: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_code_setaddr($self, $gaddr) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$gaddr; + var $3=$2; + var $4=$1; + var $5=(($4+68)|0); + var $6=(($5)|0); + HEAP32[(($6)>>2)]=$3; + var $7=$1; + var $8=(($7+84)|0); + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($10)|0)!=0; + if ($11) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $13=$2; + var $14=$1; + var $15=(($14+84)|0); + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17+68)|0); + var $19=(($18)|0); + HEAP32[(($19)>>2)]=$13; + __label__ = 4; break; + case 4: + var $21=$1; + var $22=(($21+84)|0); + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $27=$2; + var $28=$1; + var $29=(($28+84)|0); + var $30=(($29+4)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31+68)|0); + var $33=(($32)|0); + HEAP32[(($33)>>2)]=$27; + __label__ = 6; break; + case 6: + var $35=$1; + var $36=(($35+84)|0); + var $37=(($36+8)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=(($38)|0)!=0; + if ($39) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $41=$2; + var $42=$1; + var $43=(($42+84)|0); + var $44=(($43+8)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($45+68)|0); + var $47=(($46)|0); + HEAP32[(($47)>>2)]=$41; + __label__ = 8; break; + case 8: + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_code_setaddr["X"]=1; + +function _ir_value_code_addr($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$self; + var $3=$2; + var $4=(($3+8)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)==4; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$2; + var $9=(($8+68)|0); + var $10=(($9+12)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=((($11)+(1))|0); + $1=$12; + __label__ = 5; break; + case 4: + var $14=$2; + var $15=(($14+68)|0); + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$2; + var $19=(($18+68)|0); + var $20=(($19+12)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($17)+($21))|0); + $1=$22; + __label__ = 5; break; + case 5: + var $24=$1; + ; + return $24; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_instr_params_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+48)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+52)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+52)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+52)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+52)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 603, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+44)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+48)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+44)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 603, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+44)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+48)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+44)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_params_add["X"]=1; + +function _ir_value_writes_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+44)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+44)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+40)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+40)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+44)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+44)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+44)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+48)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+44)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 766, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+40)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+44)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+40)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 766, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+40)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_writes_remove["X"]=1; + +function _ir_value_reads_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+32)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+32)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+28)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+28)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+32)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+32)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+32)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+36)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+32)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 765, ((STRING_TABLE.__str9222)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+28)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+32)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+28)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 765, ((STRING_TABLE.__str9222)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+28)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_reads_remove["X"]=1; + +function _ir_instr_op($self, $op, $v, $writing) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $idx=__stackBase__; + $2=$self; + $3=$op; + $4=$v; + var $6=(($writing)&1); + $5=$6; + var $7=$3; + var $8=$2; + var $9=(($8+12)|0); + var $10=(($9+($7<<2))|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($11)|0)!=0; + if ($12) { __label__ = 3; break; } else { __label__ = 14; break; } + case 3: + var $14=$5; + var $15=(($14) & 1); + if ($15) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $17=$3; + var $18=$2; + var $19=(($18+12)|0); + var $20=(($19+($17<<2))|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$2; + var $23=_ir_value_writes_find($21, $22, $idx); + if ($23) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $25=$3; + var $26=$2; + var $27=(($26+12)|0); + var $28=(($27+($25<<2))|0); + var $29=HEAP32[(($28)>>2)]; + var $30=HEAP32[(($idx)>>2)]; + var $31=_ir_value_writes_remove($29, $30); + if ($31) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + $1=0; + __label__ = 24; break; + case 7: + __label__ = 13; break; + case 8: + var $35=$3; + var $36=$2; + var $37=(($36+12)|0); + var $38=(($37+($35<<2))|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$2; + var $41=_ir_value_reads_find($39, $40, $idx); + if ($41) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $43=$3; + var $44=$2; + var $45=(($44+12)|0); + var $46=(($45+($43<<2))|0); + var $47=HEAP32[(($46)>>2)]; + var $48=HEAP32[(($idx)>>2)]; + var $49=_ir_value_reads_remove($47, $48); + if ($49) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 24; break; + case 11: + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $55=$4; + var $56=(($55)|0)!=0; + if ($56) { __label__ = 15; break; } else { __label__ = 23; break; } + case 15: + var $58=$5; + var $59=(($58) & 1); + if ($59) { __label__ = 16; break; } else { __label__ = 19; break; } + case 16: + var $61=$4; + var $62=$2; + var $63=_ir_value_writes_add($61, $62); + if ($63) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 24; break; + case 18: + __label__ = 22; break; + case 19: + var $67=$4; + var $68=$2; + var $69=_ir_value_reads_add($67, $68); + if ($69) { __label__ = 21; break; } else { __label__ = 20; break; } + case 20: + $1=0; + __label__ = 24; break; + case 21: + __label__ = 22; break; + case 22: + __label__ = 23; break; + case 23: + var $74=$4; + var $75=$3; + var $76=$2; + var $77=(($76+12)|0); + var $78=(($77+($75<<2))|0); + HEAP32[(($78)>>2)]=$74; + $1=1; + __label__ = 24; break; + case 24: + var $80=$1; + STACKTOP = __stackBase__; + return $80; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_op["X"]=1; + +function _ir_value_writes_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+44)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+48)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+48)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+48)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+48)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+48)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 766, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+40)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+44)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+40)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 766, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+40)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+44)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+40)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_writes_add["X"]=1; + +function _ir_value_reads_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+32)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+36)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+36)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+36)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+36)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+36)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 765, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+28)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+32)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+28)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 765, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+28)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+32)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+28)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_reads_add["X"]=1; + +function _ir_value_set_name($self, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$self; + $2=$name; + var $3=$1; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$1; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + _util_memory_d($10, 804, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $12=$2; + var $13=_util_strdup($12); + var $14=$1; + var $15=(($14)|0); + HEAP32[(($15)>>2)]=$13; + var $16=$1; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=0; + var $20=$19 ^ 1; + var $21=$20 ^ 1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_set_float($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=2; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $10=$3; + var $11=$2; + var $12=(($11+56)|0); + var $13=$12; + HEAPF32[(($13)>>2)]=$10; + var $14=$2; + var $15=(($14+52)|0); + HEAP8[($15)]=1; + $1=1; + __label__ = 5; break; + case 5: + var $17=$1; + ; + return $17; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_set_field($self, $fld) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$fld; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=5; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $10=$3; + var $11=$2; + var $12=(($11+56)|0); + var $13=$12; + HEAP32[(($13)>>2)]=$10; + var $14=$2; + var $15=(($14+52)|0); + HEAP8[($15)]=1; + $1=1; + __label__ = 5; break; + case 5: + var $17=$1; + ; + return $17; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_vector_member($self, $member) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $m; + $2=$self; + $3=$member; + var $4=$3; + var $5=(($4)>>>0) >= 3; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 19; break; + case 4: + var $8=$3; + var $9=$2; + var $10=(($9+84)|0); + var $11=(($10+($8<<2))|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $15=$3; + var $16=$2; + var $17=(($16+84)|0); + var $18=(($17+($15<<2))|0); + var $19=HEAP32[(($18)>>2)]; + $1=$19; + __label__ = 19; break; + case 6: + var $21=$2; + var $22=(($21+4)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23)|0)==3; + if ($24) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $26=$2; + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$2; + var $30=(($29+8)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=_ir_value_var($28, $31, 2); + $m=$32; + var $33=$m; + var $34=(($33)|0)!=0; + if ($34) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 19; break; + case 9: + var $37=$m; + var $38=(($37+12)|0); + var $39=$2; + var $40=(($39+12)|0); + var $41=$38; + var $42=$40; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($41)>>2)]=HEAP32[(($42)>>2)];HEAP32[((($41)+(4))>>2)]=HEAP32[((($42)+(4))>>2)]; + var $43=$m; + var $44=$3; + var $45=$2; + var $46=(($45+84)|0); + var $47=(($46+($44<<2))|0); + HEAP32[(($47)>>2)]=$43; + var $48=$3; + var $49=$m; + var $50=(($49+68)|0); + var $51=(($50+12)|0); + HEAP32[(($51)>>2)]=$48; + __label__ = 18; break; + case 10: + var $53=$2; + var $54=(($53+4)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($55)|0)==5; + if ($56) { __label__ = 11; break; } else { __label__ = 16; break; } + case 11: + var $58=$2; + var $59=(($58+20)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60)|0)!=3; + if ($61) { __label__ = 12; break; } else { __label__ = 13; break; } + case 12: + $1=0; + __label__ = 19; break; + case 13: + var $64=$2; + var $65=(($64)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=$2; + var $68=(($67+8)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=_ir_value_var($66, $69, 5); + $m=$70; + var $71=$m; + var $72=(($71)|0)!=0; + if ($72) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + $1=0; + __label__ = 19; break; + case 15: + var $75=$m; + var $76=(($75+20)|0); + HEAP32[(($76)>>2)]=2; + var $77=$m; + var $78=(($77+12)|0); + var $79=$2; + var $80=(($79+12)|0); + var $81=$78; + var $82=$80; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($81)>>2)]=HEAP32[(($82)>>2)];HEAP32[((($81)+(4))>>2)]=HEAP32[((($82)+(4))>>2)]; + var $83=$m; + var $84=$3; + var $85=$2; + var $86=(($85+84)|0); + var $87=(($86+($84<<2))|0); + HEAP32[(($87)>>2)]=$83; + var $88=$3; + var $89=$m; + var $90=(($89+68)|0); + var $91=(($90+12)|0); + HEAP32[(($91)>>2)]=$88; + __label__ = 17; break; + case 16: + var $93=$2; + var $94=(($93+12)|0); + var $95=$2; + var $96=(($95)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($94)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=(($94+4)|0); + var $101=HEAP32[(($100)>>2)]; + _irerror($99, $101, ((STRING_TABLE.__str14227)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$97,tempInt)); + $1=0; + __label__ = 19; break; + case 17: + __label__ = 18; break; + case 18: + var $104=$2; + var $105=$m; + var $106=(($105+96)|0); + HEAP32[(($106)>>2)]=$104; + var $107=$m; + $1=$107; + __label__ = 19; break; + case 19: + var $109=$1; + STACKTOP = __stackBase__; + return $109; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_vector_member["X"]=1; + +function _ir_value_life_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+104)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+104)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+100)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<3))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+100)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<3))|0); + var $31=$24; + var $32=$30; + 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)]; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+104)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+104)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+104)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+108)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+104)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56<<3))|0); + var $58=_util_memory_a($57, 764, ((STRING_TABLE.__str9222)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+100)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+104)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72<<3))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4); + var $74=$2; + var $75=(($74+100)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 764, ((STRING_TABLE.__str9222)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+100)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_life_remove["X"]=1; + +function _ir_value_life_add($self, $f_0, $f_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=$2; + var $6=(($5+104)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+108)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+108)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+108)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+108)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+108)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=((($28<<3))|0); + var $30=_util_memory_a($29, 764, ((STRING_TABLE.__str9222)|0)); + var $31=$30; + $reall=$31; + var $32=$reall; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $36=$reall; + var $37=$36; + var $38=$2; + var $39=(($38+100)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + var $42=$2; + var $43=(($42+104)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44<<3))|0); + assert($45 % 1 === 0, 'memcpy given ' + $45 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $41, $45, 4); + var $46=$2; + var $47=(($46+100)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + _util_memory_d($49, 764, ((STRING_TABLE.__str9222)|0)); + var $50=$reall; + var $51=$2; + var $52=(($51+100)|0); + HEAP32[(($52)>>2)]=$50; + __label__ = 9; break; + case 9: + var $54=$2; + var $55=(($54+104)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+100)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<3))|0); + var $62=$61; + var $63=$f; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($62)>>2)]=HEAP32[(($63)>>2)];HEAP32[((($62)+(4))>>2)]=HEAP32[((($63)+(4))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_life_add["X"]=1; + +function _ir_value_out($owner, $name, $storetype, $vtype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $v; + $2=$owner; + $3=$name; + $4=$storetype; + $5=$vtype; + var $6=$3; + var $7=$4; + var $8=$5; + var $9=_ir_value_var($6, $7, $8); + $v=$9; + var $10=$v; + var $11=(($10)|0)!=0; + if ($11) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $14=$2; + var $15=$v; + var $16=_ir_function_collect_value($14, $15); + if ($16) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $18=$v; + _ir_value_delete($18); + $1=0; + __label__ = 7; break; + case 6: + var $20=$v; + $1=$20; + __label__ = 7; break; + case 7: + var $22=$1; + ; + return $22; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_set_vector($self, $v_0, $v_1, $v_2) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $v=__stackBase__; + $2=$self; + var $3=(($v)|0); + HEAPF32[(($3)>>2)]=$v_0; + var $4=(($v+4)|0); + HEAPF32[(($4)>>2)]=$v_1; + var $5=(($v+8)|0); + HEAPF32[(($5)>>2)]=$v_2; + var $6=$2; + var $7=(($6+4)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8)|0)!=3; + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $12=$2; + var $13=(($12+56)|0); + var $14=$13; + var $15=$14; + var $16=$v; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($15)>>2)]=HEAP32[(($16)>>2)];HEAP32[((($15)+(4))>>2)]=HEAP32[((($16)+(4))>>2)];HEAP32[((($15)+(8))>>2)]=HEAP32[((($16)+(8))>>2)]; + var $17=$2; + var $18=(($17+52)|0); + HEAP8[($18)]=1; + $1=1; + __label__ = 5; break; + case 5: + var $20=$1; + STACKTOP = __stackBase__; + return $20; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_set_string($self, $str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$str; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=1; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $10=$3; + var $11=_ir_strdup($10); + var $12=$2; + var $13=(($12+56)|0); + var $14=$13; + HEAP32[(($14)>>2)]=$11; + var $15=$2; + var $16=(($15+52)|0); + HEAP8[($16)]=1; + $1=1; + __label__ = 5; break; + case 5: + var $18=$1; + ; + return $18; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_strdup($str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $out; + $2=$str; + var $3=$2; + var $4=(($3)|0)!=0; + if ($4) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $6=$2; + var $7=HEAP8[($6)]; + var $8=(($7 << 24) >> 24)!=0; + if ($8) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $10=_util_memory_a(1, 849, ((STRING_TABLE.__str9222)|0)); + $out=$10; + var $11=$out; + HEAP8[($11)]=0; + var $12=$out; + $1=$12; + __label__ = 6; break; + case 5: + var $14=$2; + var $15=_util_strdup($14); + $1=$15; + __label__ = 6; break; + case 6: + var $17=$1; + ; + return $17; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_value_life_insert($self, $idx, $e_0, $e_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $e=__stackBase__; + var $k; + $2=$self; + $3=$idx; + var $4=(($e)|0); + HEAP32[(($4)>>2)]=$e_0; + var $5=(($e+4)|0); + HEAP32[(($5)>>2)]=$e_1; + var $6=$2; + var $7=(($e)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($e+4)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=_ir_value_life_add($6, $8, $10); + if ($11) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 9; break; + case 4: + var $14=$2; + var $15=(($14+104)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + $k=$17; + __label__ = 5; break; + case 5: + var $19=$k; + var $20=$3; + var $21=(($19)>>>0) > (($20)>>>0); + if ($21) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $23=$k; + var $24=$2; + var $25=(($24+100)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<3))|0); + var $28=$k; + var $29=((($28)-(1))|0); + var $30=$2; + var $31=(($30+100)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=(($32+($29<<3))|0); + var $34=$27; + var $35=$33; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($34)>>2)]=HEAP32[(($35)>>2)];HEAP32[((($34)+(4))>>2)]=HEAP32[((($35)+(4))>>2)]; + __label__ = 7; break; + case 7: + var $37=$k; + var $38=((($37)-(1))|0); + $k=$38; + __label__ = 5; break; + case 8: + var $40=$3; + var $41=$2; + var $42=(($41+100)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($43+($40<<3))|0); + var $45=$44; + var $46=$e; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($45)>>2)]=HEAP32[(($46)>>2)];HEAP32[((($45)+(4))>>2)]=HEAP32[((($46)+(4))>>2)]; + $1=1; + __label__ = 9; break; + case 9: + var $48=$1; + STACKTOP = __stackBase__; + return $48; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_life_insert["X"]=1; + +function _ir_value_life_merge($self, $s) { + var __stackBase__ = STACKTOP; STACKTOP += 16; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $life; + var $before; + var $new_entry=__stackBase__; + var $e=(__stackBase__)+(8); + $2=$self; + $3=$s; + $life=0; + $before=0; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+104)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$life; + $before=$11; + var $12=$i; + var $13=$2; + var $14=(($13+100)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<3))|0); + $life=$16; + var $17=$life; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$3; + var $21=(($19)>>>0) > (($20)>>>0); + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + __label__ = 8; break; + case 6: + __label__ = 7; break; + case 7: + var $25=$i; + var $26=((($25)+(1))|0); + $i=$26; + __label__ = 3; break; + case 8: + var $28=$i; + var $29=$2; + var $30=(($29+104)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($28)|0)==(($31)|0); + if ($32) { __label__ = 9; break; } else { __label__ = 18; break; } + case 9: + var $34=$life; + var $35=(($34)|0)!=0; + if ($35) { __label__ = 10; break; } else { __label__ = 12; break; } + case 10: + var $37=$life; + var $38=(($37+4)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)+(1))|0); + var $41=$3; + var $42=(($40)|0)==(($41)|0); + if ($42) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $44=$life; + var $45=(($44+4)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=((($46)+(1))|0); + HEAP32[(($45)>>2)]=$47; + $1=1; + __label__ = 32; break; + case 12: + var $49=$life; + var $50=(($49)|0)!=0; + if ($50) { __label__ = 13; break; } else { __label__ = 15; break; } + case 13: + var $52=$life; + var $53=(($52+4)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=$3; + var $56=(($54)>>>0) >= (($55)>>>0); + if ($56) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + $1=0; + __label__ = 32; break; + case 15: + var $59=$3; + var $60=(($e+4)|0); + HEAP32[(($60)>>2)]=$59; + var $61=(($e)|0); + HEAP32[(($61)>>2)]=$59; + var $62=$2; + var $63=(($e)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($e+4)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=_ir_value_life_add($62, $64, $66); + if ($67) { __label__ = 17; break; } else { __label__ = 16; break; } + case 16: + $1=0; + __label__ = 32; break; + case 17: + $1=1; + __label__ = 32; break; + case 18: + var $71=$before; + var $72=(($71)|0)!=0; + if ($72) { __label__ = 19; break; } else { __label__ = 29; break; } + case 19: + var $74=$before; + var $75=(($74+4)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=((($76)+(1))|0); + var $78=$3; + var $79=(($77)|0)==(($78)|0); + if ($79) { __label__ = 20; break; } else { __label__ = 24; break; } + case 20: + var $81=$life; + var $82=(($81)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=((($83)-(1))|0); + var $85=$3; + var $86=(($84)|0)==(($85)|0); + if ($86) { __label__ = 21; break; } else { __label__ = 24; break; } + case 21: + var $88=$life; + var $89=(($88+4)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=$before; + var $92=(($91+4)|0); + HEAP32[(($92)>>2)]=$90; + var $93=$2; + var $94=$i; + var $95=_ir_value_life_remove($93, $94); + if ($95) { __label__ = 23; break; } else { __label__ = 22; break; } + case 22: + $1=0; + __label__ = 32; break; + case 23: + $1=1; + __label__ = 32; break; + case 24: + var $99=$before; + var $100=(($99+4)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=((($101)+(1))|0); + var $103=$3; + var $104=(($102)|0)==(($103)|0); + if ($104) { __label__ = 25; break; } else { __label__ = 26; break; } + case 25: + var $106=$before; + var $107=(($106+4)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=((($108)+(1))|0); + HEAP32[(($107)>>2)]=$109; + $1=1; + __label__ = 32; break; + case 26: + var $111=$before; + var $112=(($111+4)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$3; + var $115=(($113)>>>0) >= (($114)>>>0); + if ($115) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + $1=0; + __label__ = 32; break; + case 28: + __label__ = 29; break; + case 29: + var $119=$life; + var $120=(($119)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=((($121)-(1))|0); + var $123=$3; + var $124=(($122)|0)==(($123)|0); + if ($124) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + var $126=$life; + var $127=(($126)|0); + var $128=HEAP32[(($127)>>2)]; + var $129=((($128)-(1))|0); + HEAP32[(($127)>>2)]=$129; + $1=1; + __label__ = 32; break; + case 31: + var $131=$3; + var $132=(($new_entry+4)|0); + HEAP32[(($132)>>2)]=$131; + var $133=(($new_entry)|0); + HEAP32[(($133)>>2)]=$131; + var $134=$2; + var $135=$i; + var $136=(($new_entry)|0); + var $137=HEAP32[(($136)>>2)]; + var $138=(($new_entry+4)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=_ir_value_life_insert($134, $135, $137, $139); + $1=$140; + __label__ = 32; break; + case 32: + var $142=$1; + STACKTOP = __stackBase__; + return $142; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_life_merge["X"]=1; + +function _ir_values_overlap($a, $b) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $la; + var $lb; + var $enda; + var $endb; + $2=$a; + $3=$b; + var $4=$2; + var $5=(($4+104)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$3; + var $10=(($9+104)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($11)|0)!=0; + if ($12) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 18; break; + case 5: + var $15=$2; + var $16=(($15+100)|0); + var $17=HEAP32[(($16)>>2)]; + $la=$17; + var $18=$3; + var $19=(($18+100)|0); + var $20=HEAP32[(($19)>>2)]; + $lb=$20; + var $21=$la; + var $22=$2; + var $23=(($22+104)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($21+($24<<3))|0); + $enda=$25; + var $26=$lb; + var $27=$3; + var $28=(($27+104)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($26+($29<<3))|0); + $endb=$30; + __label__ = 6; break; + case 6: + var $32=$la; + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$lb; + var $36=(($35+4)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($34)>>>0) < (($37)>>>0); + if ($38) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $40=$lb; + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$la; + var $44=(($43+4)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($42)>>>0) < (($45)>>>0); + if ($46) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + $1=1; + __label__ = 18; break; + case 9: + var $49=$la; + var $50=(($49)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=$lb; + var $53=(($52)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=(($51)>>>0) < (($54)>>>0); + if ($55) { __label__ = 10; break; } else { __label__ = 13; break; } + case 10: + var $57=$la; + var $58=(($57+8)|0); + $la=$58; + var $59=$enda; + var $60=(($58)|0)==(($59)|0); + if ($60) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + __label__ = 17; break; + case 12: + __label__ = 16; break; + case 13: + var $64=$lb; + var $65=(($64+8)|0); + $lb=$65; + var $66=$endb; + var $67=(($65)|0)==(($66)|0); + if ($67) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + __label__ = 17; break; + case 15: + __label__ = 16; break; + case 16: + __label__ = 6; break; + case 17: + $1=0; + __label__ = 18; break; + case 18: + var $73=$1; + ; + return $73; + default: assert(0, "bad label: " + __label__); + } +} +_ir_values_overlap["X"]=1; + +function _ir_call_value($self) { + ; + var __label__; + + var $1; + $1=$self; + var $2=$1; + var $3=(($2+12)|0); + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + ; + return $5; +} + + +function _ir_value_life_merge_into($self, $other) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $myi; + var $life; + var $entry; + $2=$self; + $3=$other; + var $4=$3; + var $5=(($4+104)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=1; + __label__ = 44; break; + case 4: + var $10=$2; + var $11=(($10+104)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 12; break; } else { __label__ = 5; break; } + case 5: + $i=0; + __label__ = 6; break; + case 6: + var $16=$i; + var $17=$3; + var $18=(($17+104)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($16)>>>0) < (($19)>>>0); + if ($20) { __label__ = 7; break; } else { __label__ = 11; break; } + case 7: + var $22=$2; + var $23=$i; + var $24=$3; + var $25=(($24+100)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<3))|0); + var $28=(($27)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($27+4)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=_ir_value_life_add($22, $29, $31); + if ($32) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 44; break; + case 9: + __label__ = 10; break; + case 10: + var $36=$i; + var $37=((($36)+(1))|0); + $i=$37; + __label__ = 6; break; + case 11: + $1=1; + __label__ = 44; break; + case 12: + $myi=0; + $i=0; + __label__ = 13; break; + case 13: + var $41=$i; + var $42=$3; + var $43=(($42+104)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($41)>>>0) < (($44)>>>0); + if ($45) { __label__ = 14; break; } else { __label__ = 43; break; } + case 14: + var $47=$i; + var $48=$3; + var $49=(($48+100)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($50+($47<<3))|0); + $life=$51; + __label__ = 15; break; + case 15: + var $53=$myi; + var $54=$2; + var $55=(($54+100)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+($53<<3))|0); + $entry=$57; + var $58=$life; + var $59=(($58+4)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=((($60)+(1))|0); + var $62=$entry; + var $63=(($62)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($61)>>>0) < (($64)>>>0); + if ($65) { __label__ = 16; break; } else { __label__ = 19; break; } + case 16: + var $67=$2; + var $68=$myi; + var $69=$life; + var $70=(($69)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=(($69+4)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=_ir_value_life_insert($67, $68, $71, $73); + if ($74) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 44; break; + case 18: + var $77=$myi; + var $78=((($77)+(1))|0); + $myi=$78; + __label__ = 41; break; + case 19: + var $80=$life; + var $81=(($80)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=$entry; + var $84=(($83)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=(($82)>>>0) < (($85)>>>0); + if ($86) { __label__ = 20; break; } else { __label__ = 22; break; } + case 20: + var $88=$life; + var $89=(($88+4)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=((($90)+(1))|0); + var $92=$entry; + var $93=(($92)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=(($91)>>>0) >= (($94)>>>0); + if ($95) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $97=$life; + var $98=(($97)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=$entry; + var $101=(($100)|0); + HEAP32[(($101)>>2)]=$99; + __label__ = 22; break; + case 22: + var $103=$life; + var $104=(($103+4)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=$entry; + var $107=(($106+4)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($105)>>>0) > (($108)>>>0); + if ($109) { __label__ = 23; break; } else { __label__ = 25; break; } + case 23: + var $111=$life; + var $112=(($111)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$entry; + var $115=(($114+4)|0); + var $116=HEAP32[(($115)>>2)]; + var $117=((($116)+(1))|0); + var $118=(($113)>>>0) <= (($117)>>>0); + if ($118) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + var $120=$life; + var $121=(($120+4)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=$entry; + var $124=(($123+4)|0); + HEAP32[(($124)>>2)]=$122; + __label__ = 25; break; + case 25: + __label__ = 26; break; + case 26: + var $127=$myi; + var $128=((($127)+(1))|0); + var $129=$2; + var $130=(($129+104)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=(($128)>>>0) < (($131)>>>0); + if ($132) { __label__ = 27; break; } else { var $148 = 0;__label__ = 28; break; } + case 27: + var $134=$entry; + var $135=(($134+4)|0); + var $136=HEAP32[(($135)>>2)]; + var $137=((($136)+(1))|0); + var $138=$myi; + var $139=((($138)+(1))|0); + var $140=$2; + var $141=(($140+100)|0); + var $142=HEAP32[(($141)>>2)]; + var $143=(($142+($139<<3))|0); + var $144=(($143)|0); + var $145=HEAP32[(($144)>>2)]; + var $146=(($137)>>>0) >= (($145)>>>0); + var $148 = $146;__label__ = 28; break; + case 28: + var $148; + if ($148) { __label__ = 29; break; } else { __label__ = 34; break; } + case 29: + var $150=$entry; + var $151=(($150+4)|0); + var $152=HEAP32[(($151)>>2)]; + var $153=$myi; + var $154=((($153)+(1))|0); + var $155=$2; + var $156=(($155+100)|0); + var $157=HEAP32[(($156)>>2)]; + var $158=(($157+($154<<3))|0); + var $159=(($158+4)|0); + var $160=HEAP32[(($159)>>2)]; + var $161=(($152)>>>0) < (($160)>>>0); + if ($161) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + var $163=$myi; + var $164=((($163)+(1))|0); + var $165=$2; + var $166=(($165+100)|0); + var $167=HEAP32[(($166)>>2)]; + var $168=(($167+($164<<3))|0); + var $169=(($168+4)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=$entry; + var $172=(($171+4)|0); + HEAP32[(($172)>>2)]=$170; + __label__ = 31; break; + case 31: + var $174=$2; + var $175=$myi; + var $176=((($175)+(1))|0); + var $177=_ir_value_life_remove($174, $176); + if ($177) { __label__ = 33; break; } else { __label__ = 32; break; } + case 32: + $1=0; + __label__ = 44; break; + case 33: + var $180=$myi; + var $181=$2; + var $182=(($181+100)|0); + var $183=HEAP32[(($182)>>2)]; + var $184=(($183+($180<<3))|0); + $entry=$184; + __label__ = 26; break; + case 34: + var $186=$life; + var $187=(($186)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=$entry; + var $190=(($189+4)|0); + var $191=HEAP32[(($190)>>2)]; + var $192=(($188)>>>0) > (($191)>>>0); + if ($192) { __label__ = 35; break; } else { __label__ = 40; break; } + case 35: + var $194=$myi; + var $195=((($194)+(1))|0); + $myi=$195; + var $196=$myi; + var $197=$2; + var $198=(($197+104)|0); + var $199=HEAP32[(($198)>>2)]; + var $200=(($196)>>>0) >= (($199)>>>0); + if ($200) { __label__ = 36; break; } else { __label__ = 39; break; } + case 36: + var $202=$2; + var $203=$life; + var $204=(($203)|0); + var $205=HEAP32[(($204)>>2)]; + var $206=(($203+4)|0); + var $207=HEAP32[(($206)>>2)]; + var $208=_ir_value_life_add($202, $205, $207); + if ($208) { __label__ = 38; break; } else { __label__ = 37; break; } + case 37: + $1=0; + __label__ = 44; break; + case 38: + __label__ = 41; break; + case 39: + __label__ = 15; break; + case 40: + __label__ = 41; break; + case 41: + __label__ = 42; break; + case 42: + var $215=$i; + var $216=((($215)+(1))|0); + $i=$216; + __label__ = 13; break; + case 43: + $1=1; + __label__ = 44; break; + case 44: + var $219=$1; + ; + return $219; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_life_merge_into["X"]=1; + +function _ir_block_create_store_op($self, $op, $target, $what) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $in; + $2=$self; + $3=$op; + $4=$target; + $5=$what; + var $6=$2; + var $7=$3; + var $8=_ir_instr_new($6, $7); + $in=$8; + var $9=$in; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 13; break; + case 4: + var $13=$4; + var $14=(($13+8)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)==3; + if ($16) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $18=$3; + var $19=(($18)|0) < 37; + if ($19) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $21=$3; + var $22=(($21)|0) > 42; + if ($22) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $24=$2; + var $25=(($24+4)|0); + var $26=(($25)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($25+4)|0); + var $29=HEAP32[(($28)>>2)]; + _irerror($27, $29, ((STRING_TABLE.__str15228)|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)); + var $30=$2; + var $31=(($30+4)|0); + var $32=$4; + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$5; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($31)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($31+4)|0); + var $41=HEAP32[(($40)>>2)]; + _irerror($39, $41, ((STRING_TABLE.__str16229)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$34,HEAP32[(((tempInt)+(4))>>2)]=$37,tempInt)); + var $42=$2; + var $43=(($42+4)|0); + var $44=$3; + var $45=((_asm_instr231+($44)*(12))|0); + var $46=(($45)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($43)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($43+4)|0); + var $51=HEAP32[(($50)>>2)]; + _irerror($49, $51, ((STRING_TABLE.__str17230)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$47,tempInt)); + $1=0; + __label__ = 13; break; + case 8: + var $53=$in; + var $54=$4; + var $55=_ir_instr_op($53, 0, $54, 1); + if ($55) { __label__ = 9; break; } else { __label__ = 11; break; } + case 9: + var $57=$in; + var $58=$5; + var $59=_ir_instr_op($57, 1, $58, 0); + if ($59) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $61=$2; + var $62=$in; + var $63=_ir_block_instr_add($61, $62); + if ($63) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 13; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $67=$1; + STACKTOP = __stackBase__; + return $67; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_store_op["X"]=1; + +function _ir_block_create_store($self, $target, $what) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $op; + var $vtype; + $1=$self; + $2=$target; + $3=$what; + $op=0; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)==9; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$3; + var $10=(($9+4)|0); + var $11=HEAP32[(($10)>>2)]; + $vtype=$11; + __label__ = 5; break; + case 4: + var $13=$2; + var $14=(($13+4)|0); + var $15=HEAP32[(($14)>>2)]; + $vtype=$15; + __label__ = 5; break; + case 5: + var $17=$vtype; + var $18=((_type_store_instr+($17<<1))|0); + var $19=HEAP16[(($18)>>1)]; + var $20=(($19)&65535); + $op=$20; + var $21=HEAP32[((((_opts_flags)|0))>>2)]; + var $22=$21 & 8; + var $23=(($22)|0)!=0; + if ($23) { __label__ = 6; break; } else { __label__ = 10; break; } + case 6: + var $25=$op; + var $26=(($25)|0)==35; + if ($26) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $28=$3; + var $29=(($28+20)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)==3; + if ($31) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + $op=32; + __label__ = 9; break; + case 9: + __label__ = 10; break; + case 10: + var $35=$1; + var $36=$op; + var $37=$2; + var $38=$3; + var $39=_ir_block_create_store_op($35, $36, $37, $38); + ; + return $39; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_store["X"]=1; + +function _ir_block_create_return($self, $v) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $in; + $2=$self; + $3=$v; + var $4=$2; + var $5=(($4+12)|0); + var $6=HEAP8[($5)]; + var $7=(($6) & 1); + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$2; + var $10=(($9+4)|0); + var $11=$2; + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($10)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($10+4)|0); + var $17=HEAP32[(($16)>>2)]; + _irerror($15, $17, ((STRING_TABLE.__str18232)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$13,tempInt)); + $1=0; + __label__ = 12; break; + case 4: + var $19=$2; + var $20=(($19+12)|0); + HEAP8[($20)]=1; + var $21=$2; + var $22=(($21+68)|0); + HEAP8[($22)]=1; + var $23=$2; + var $24=_ir_instr_new($23, 43); + $in=$24; + var $25=$in; + var $26=(($25)|0)!=0; + if ($26) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 12; break; + case 6: + var $29=$3; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $32=$in; + var $33=$3; + var $34=_ir_instr_op($32, 0, $33, 0); + if ($34) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 12; break; + case 9: + var $37=$2; + var $38=$in; + var $39=_ir_block_instr_add($37, $38); + if ($39) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 12; break; + case 11: + $1=1; + __label__ = 12; break; + case 12: + var $43=$1; + STACKTOP = __stackBase__; + return $43; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_return["X"]=1; + +function _ir_block_create_if($self, $v, $ontrue, $onfalse) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $in; + $2=$self; + $3=$v; + $4=$ontrue; + $5=$onfalse; + var $6=$2; + var $7=(($6+12)|0); + var $8=HEAP8[($7)]; + var $9=(($8) & 1); + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $11=$2; + var $12=(($11+4)|0); + var $13=$2; + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($12+4)|0); + var $19=HEAP32[(($18)>>2)]; + _irerror($17, $19, ((STRING_TABLE.__str18232)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$15,tempInt)); + $1=0; + __label__ = 16; break; + case 4: + var $21=$2; + var $22=(($21+12)|0); + HEAP8[($22)]=1; + var $23=$2; + var $24=_ir_instr_new($23, 69); + $in=$24; + var $25=$in; + var $26=(($25)|0)!=0; + if ($26) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 16; break; + case 6: + var $29=$in; + var $30=$3; + var $31=_ir_instr_op($29, 0, $30, 0); + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $33=$in; + _ir_instr_delete($33); + $1=0; + __label__ = 16; break; + case 8: + var $35=$4; + var $36=$in; + var $37=(($36+24)|0); + var $38=(($37)|0); + HEAP32[(($38)>>2)]=$35; + var $39=$5; + var $40=$in; + var $41=(($40+24)|0); + var $42=(($41+4)|0); + HEAP32[(($42)>>2)]=$39; + var $43=$2; + var $44=$in; + var $45=_ir_block_instr_add($43, $44); + if ($45) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 16; break; + case 10: + var $48=$2; + var $49=$4; + var $50=_ir_block_exits_add($48, $49); + if ($50) { __label__ = 11; break; } else { __label__ = 14; break; } + case 11: + var $52=$2; + var $53=$5; + var $54=_ir_block_exits_add($52, $53); + if ($54) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $56=$4; + var $57=$2; + var $58=_ir_block_entries_add($56, $57); + if ($58) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $60=$5; + var $61=$2; + var $62=_ir_block_entries_add($60, $61); + if ($62) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + $1=0; + __label__ = 16; break; + case 15: + $1=1; + __label__ = 16; break; + case 16: + var $66=$1; + STACKTOP = __stackBase__; + return $66; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_if["X"]=1; + +function _ir_block_create_jump($self, $to) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $in; + $2=$self; + $3=$to; + var $4=$2; + var $5=(($4+12)|0); + var $6=HEAP8[($5)]; + var $7=(($6) & 1); + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$2; + var $10=(($9+4)|0); + var $11=$2; + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($10)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($10+4)|0); + var $17=HEAP32[(($16)>>2)]; + _irerror($15, $17, ((STRING_TABLE.__str18232)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$13,tempInt)); + $1=0; + __label__ = 12; break; + case 4: + var $19=$2; + var $20=(($19+12)|0); + HEAP8[($20)]=1; + var $21=$2; + var $22=_ir_instr_new($21, 68); + $in=$22; + var $23=$in; + var $24=(($23)|0)!=0; + if ($24) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 12; break; + case 6: + var $27=$3; + var $28=$in; + var $29=(($28+24)|0); + var $30=(($29)|0); + HEAP32[(($30)>>2)]=$27; + var $31=$2; + var $32=$in; + var $33=_ir_block_instr_add($31, $32); + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 12; break; + case 8: + var $36=$2; + var $37=$3; + var $38=_ir_block_exits_add($36, $37); + if ($38) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $40=$3; + var $41=$2; + var $42=_ir_block_entries_add($40, $41); + if ($42) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 12; break; + case 11: + $1=1; + __label__ = 12; break; + case 12: + var $46=$1; + STACKTOP = __stackBase__; + return $46; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_jump["X"]=1; + +function _ir_block_create_call($self, $label, $func) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $out; + var $in; + $2=$self; + $3=$label; + $4=$func; + var $5=$2; + var $6=_ir_instr_new($5, 51); + $in=$6; + var $7=$in; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 11; break; + case 4: + var $11=$2; + var $12=(($11+76)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$3; + var $15=$4; + var $16=(($15+24)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0)==0; + var $19=$18 ? 4 : 3; + var $20=$4; + var $21=(($20+24)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=_ir_value_out($13, $14, $19, $22); + $out=$23; + var $24=$out; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $27=$in; + _ir_instr_delete($27); + $1=0; + __label__ = 11; break; + case 6: + var $29=$in; + var $30=$out; + var $31=_ir_instr_op($29, 0, $30, 1); + if ($31) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $33=$in; + var $34=$4; + var $35=_ir_instr_op($33, 1, $34, 0); + if ($35) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $37=$2; + var $38=$in; + var $39=_ir_block_instr_add($37, $38); + if ($39) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $41=$in; + _ir_instr_delete($41); + var $42=$out; + _ir_value_delete($42); + $1=0; + __label__ = 11; break; + case 10: + var $44=$in; + $1=$44; + __label__ = 11; break; + case 11: + var $46=$1; + ; + return $46; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_call["X"]=1; + +function _ir_block_enumerate($self, $_eid) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $eid; + $1=$self; + $2=$_eid; + var $3=$2; + var $4=HEAP32[(($3)>>2)]; + $eid=$4; + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$1; + var $8=(($7+20)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)>>>0) < (($9)>>>0); + if ($10) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $12=$eid; + var $13=((($12)+(1))|0); + $eid=$13; + var $14=$i; + var $15=$1; + var $16=(($15+16)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17+($14<<2))|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($19+56)|0); + HEAP32[(($20)>>2)]=$12; + __label__ = 5; break; + case 5: + var $22=$i; + var $23=((($22)+(1))|0); + $i=$23; + __label__ = 3; break; + case 6: + var $25=$eid; + var $26=$2; + HEAP32[(($26)>>2)]=$25; + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_call_param($self, $v) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$self; + $3=$v; + var $4=$2; + var $5=$3; + var $6=_ir_instr_params_add($4, $5); + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 11; break; + case 4: + var $9=$3; + var $10=$2; + var $11=_ir_value_reads_add($9, $10); + if ($11) { __label__ = 10; break; } else { __label__ = 5; break; } + case 5: + var $13=$2; + var $14=$2; + var $15=(($14+48)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=_ir_instr_params_remove($13, $17); + if ($18) { __label__ = 9; break; } else { __label__ = 6; break; } + case 6: + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + $1=0; + __label__ = 11; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $25=$1; + ; + return $25; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_create_binop($self, $label, $opcode, $left, $right) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + var $ot; + $2=$self; + $3=$label; + $4=$opcode; + $5=$left; + $6=$right; + $ot=0; + var $7=$4; + if ((($7)|0) == 6 || (($7)|0) == 8 || (($7)|0) == 5 || (($7)|0) == 1 || (($7)|0) == 2 || (($7)|0) == 62 || (($7)|0) == 63 || (($7)|0) == 64 || (($7)|0) == 65) { + __label__ = 3; break; + } + else if ((($7)|0) == 7 || (($7)|0) == 9 || (($7)|0) == 4 || (($7)|0) == 3) { + __label__ = 4; break; + } + else { + __label__ = 5; break; + } + + case 3: + $ot=2; + __label__ = 13; break; + case 4: + $ot=3; + __label__ = 13; break; + case 5: + var $11=$4; + var $12=(($11)|0) >= 10; + if ($12) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $14=$4; + var $15=(($14)|0) <= 23; + if ($15) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + $ot=2; + __label__ = 12; break; + case 8: + var $18=$4; + var $19=(($18)|0) >= 20; + if ($19) { __label__ = 9; break; } else { __label__ = 11; break; } + case 9: + var $21=$4; + var $22=(($21)|0) <= 23; + if ($22) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + $ot=2; + __label__ = 11; break; + case 11: + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + var $27=$ot; + var $28=(($27)|0)==0; + if ($28) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + $1=0; + __label__ = 16; break; + case 15: + var $31=$2; + var $32=$3; + var $33=$4; + var $34=$5; + var $35=$6; + var $36=$ot; + var $37=_ir_block_create_general_instr($31, $32, $33, $34, $35, $36); + $1=$37; + __label__ = 16; break; + case 16: + var $39=$1; + ; + return $39; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_binop["X"]=1; + +function _ir_block_create_general_instr($self, $label, $op, $a, $b, $outype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + var $7; + var $instr; + var $out; + $2=$self; + $3=$label; + $4=$op; + $5=$a; + $6=$b; + $7=$outype; + var $8=$2; + var $9=(($8+76)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=$3; + var $12=$7; + var $13=_ir_value_out($10, $11, 3, $12); + $out=$13; + var $14=$out; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 14; break; + case 4: + var $18=$2; + var $19=$4; + var $20=_ir_instr_new($18, $19); + $instr=$20; + var $21=$instr; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $24=$out; + _ir_value_delete($24); + $1=0; + __label__ = 14; break; + case 6: + var $26=$instr; + var $27=$out; + var $28=_ir_instr_op($26, 0, $27, 1); + if ($28) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $30=$instr; + var $31=$5; + var $32=_ir_instr_op($30, 1, $31, 0); + if ($32) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $34=$instr; + var $35=$6; + var $36=_ir_instr_op($34, 2, $35, 0); + if ($36) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + __label__ = 13; break; + case 10: + var $39=$2; + var $40=$instr; + var $41=_ir_block_instr_add($39, $40); + if ($41) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + __label__ = 13; break; + case 12: + var $44=$out; + $1=$44; + __label__ = 14; break; + case 13: + var $46=$instr; + _ir_instr_delete($46); + var $47=$out; + _ir_value_delete($47); + $1=0; + __label__ = 14; break; + case 14: + var $49=$1; + ; + return $49; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_general_instr["X"]=1; + +function _ir_block_create_unary($self, $label, $opcode, $operand) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $ot; + $2=$self; + $3=$label; + $4=$opcode; + $5=$operand; + $ot=2; + var $6=$4; + if ((($6)|0) == 44 || (($6)|0) == 45 || (($6)|0) == 46 || (($6)|0) == 47 || (($6)|0) == 48) { + __label__ = 3; break; + } + else { + __label__ = 4; break; + } + + case 3: + $ot=2; + __label__ = 5; break; + case 4: + var $9=$5; + var $10=(($9+4)|0); + var $11=HEAP32[(($10)>>2)]; + $ot=$11; + __label__ = 5; break; + case 5: + var $13=$ot; + var $14=(($13)|0)==0; + if ($14) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + $1=0; + __label__ = 8; break; + case 7: + var $17=$2; + var $18=$3; + var $19=$4; + var $20=$5; + var $21=$ot; + var $22=_ir_block_create_general_instr($17, $18, $19, $20, 0, $21); + $1=$22; + __label__ = 8; break; + case 8: + var $24=$1; + ; + return $24; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_create_fieldaddress($self, $label, $ent, $field) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $v; + $2=$self; + $3=$label; + $4=$ent; + $5=$field; + var $6=$4; + var $7=(($6+4)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8)|0)!=4; + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $12=$5; + var $13=(($12+4)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=5; + if ($15) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 7; break; + case 6: + var $18=$2; + var $19=$3; + var $20=$4; + var $21=$5; + var $22=_ir_block_create_general_instr($18, $19, 30, $20, $21, 7); + $v=$22; + var $23=$5; + var $24=(($23+20)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=$v; + var $27=(($26+20)|0); + HEAP32[(($27)>>2)]=$25; + var $28=$v; + $1=$28; + __label__ = 7; break; + case 7: + var $30=$1; + ; + return $30; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_block_create_load_from_ent($self, $label, $ent, $field, $outype) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + var $op; + $2=$self; + $3=$label; + $4=$ent; + $5=$field; + $6=$outype; + var $7=$4; + var $8=(($7+4)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($9)|0)!=4; + if ($10) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 15; break; + case 4: + var $13=$5; + var $14=(($13+4)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=5; + if ($16) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 15; break; + case 6: + var $19=$6; + if ((($19)|0) == 2) { + __label__ = 7; break; + } + else if ((($19)|0) == 3) { + __label__ = 8; break; + } + else if ((($19)|0) == 1) { + __label__ = 9; break; + } + else if ((($19)|0) == 5) { + __label__ = 10; break; + } + else if ((($19)|0) == 4) { + __label__ = 11; break; + } + else if ((($19)|0) == 6) { + __label__ = 12; break; + } + else { + __label__ = 13; break; + } + + case 7: + $op=24; + __label__ = 14; break; + case 8: + $op=25; + __label__ = 14; break; + case 9: + $op=26; + __label__ = 14; break; + case 10: + $op=28; + __label__ = 14; break; + case 11: + $op=27; + __label__ = 14; break; + case 12: + $op=29; + __label__ = 14; break; + case 13: + $1=0; + __label__ = 15; break; + case 14: + var $28=$2; + var $29=$3; + var $30=$op; + var $31=$4; + var $32=$5; + var $33=$6; + var $34=_ir_block_create_general_instr($28, $29, $30, $31, $32, $33); + $1=$34; + __label__ = 15; break; + case 15: + var $36=$1; + ; + return $36; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_create_load_from_ent["X"]=1; + +function _ir_block_naive_phi($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $p; + var $w; + var $instr; + var $v; + var $old; + var $r; + var $op; + var $ri; + $2=$self; + $i=0; + __label__ = 3; break; + case 3: + var $4=$i; + var $5=$2; + var $6=(($5+20)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) < (($7)>>>0); + if ($8) { __label__ = 4; break; } else { __label__ = 48; break; } + case 4: + var $10=$i; + var $11=$2; + var $12=(($11+16)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + $instr=$15; + var $16=$instr; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)!=67; + if ($19) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + __label__ = 47; break; + case 6: + var $22=$2; + var $23=$i; + var $24=_ir_block_instr_remove($22, $23); + if ($24) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 49; break; + case 8: + var $27=$i; + var $28=((($27)-(1))|0); + $i=$28; + $p=0; + __label__ = 9; break; + case 9: + var $30=$p; + var $31=$instr; + var $32=(($31+36)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($30)>>>0) < (($33)>>>0); + if ($34) { __label__ = 10; break; } else { __label__ = 46; break; } + case 10: + var $36=$p; + var $37=$instr; + var $38=(($37+32)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($39+($36<<3))|0); + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + $v=$42; + $w=0; + __label__ = 11; break; + case 11: + var $44=$w; + var $45=$v; + var $46=(($45+44)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($44)>>>0) < (($47)>>>0); + if ($48) { __label__ = 12; break; } else { __label__ = 44; break; } + case 12: + var $50=$w; + var $51=$v; + var $52=(($51+40)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($53+($50<<2))|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($55+12)|0); + var $57=(($56)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58)|0)!=0; + if ($59) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + __label__ = 43; break; + case 14: + var $62=$w; + var $63=$v; + var $64=(($63+40)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($65+($62<<2))|0); + var $67=HEAP32[(($66)>>2)]; + var $68=(($67+12)|0); + var $69=(($68)|0); + var $70=HEAP32[(($69)>>2)]; + $old=$70; + var $71=$w; + var $72=$v; + var $73=(($72+40)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($74+($71<<2))|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($76+12)|0); + var $78=(($77)|0); + var $79=HEAP32[(($78)>>2)]; + var $80=$v; + var $81=(($79)|0)==(($80)|0); + if ($81) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $83=$instr; + var $84=(($83+12)|0); + var $85=(($84)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=$w; + var $88=$v; + var $89=(($88+40)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=(($90+($87<<2))|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($92+12)|0); + var $94=(($93)|0); + HEAP32[(($94)>>2)]=$86; + __label__ = 16; break; + case 16: + var $96=$old; + var $97=(($96+8)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=(($98)|0)!=3; + if ($99) { __label__ = 17; break; } else { __label__ = 25; break; } + case 17: + var $101=$old; + var $102=(($101+8)|0); + var $103=HEAP32[(($102)>>2)]; + var $104=(($103)|0)!=1; + if ($104) { __label__ = 18; break; } else { __label__ = 25; break; } + case 18: + var $106=$old; + var $107=(($106+8)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108)|0)!=2; + if ($109) { __label__ = 19; break; } else { __label__ = 25; break; } + case 19: + var $111=$2; + var $112=$i; + var $113=((($112)+(1))|0); + var $114=$old; + var $115=$v; + var $116=_ir_naive_phi_emit_store($111, $113, $114, $115); + if ($116) { __label__ = 21; break; } else { __label__ = 20; break; } + case 20: + $1=0; + __label__ = 49; break; + case 21: + var $119=$i; + var $120=((($119)+(1))|0); + var $121=$2; + var $122=(($121+20)|0); + var $123=HEAP32[(($122)>>2)]; + var $124=(($120)>>>0) < (($123)>>>0); + if ($124) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $126=$i; + var $127=((($126)+(1))|0); + var $128=$2; + var $129=(($128+16)|0); + var $130=HEAP32[(($129)>>2)]; + var $131=(($130+($127<<2))|0); + var $132=HEAP32[(($131)>>2)]; + $instr=$132; + __label__ = 24; break; + case 23: + $instr=0; + __label__ = 24; break; + case 24: + __label__ = 42; break; + case 25: + $r=0; + __label__ = 26; break; + case 26: + var $137=$r; + var $138=$old; + var $139=(($138+32)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=(($137)>>>0) < (($140)>>>0); + if ($141) { __label__ = 27; break; } else { __label__ = 41; break; } + case 27: + var $143=$r; + var $144=$old; + var $145=(($144+28)|0); + var $146=HEAP32[(($145)>>2)]; + var $147=(($146+($143<<2))|0); + var $148=HEAP32[(($147)>>2)]; + $ri=$148; + $op=0; + __label__ = 28; break; + case 28: + var $150=$op; + var $151=$ri; + var $152=(($151+36)|0); + var $153=HEAP32[(($152)>>2)]; + var $154=(($150)>>>0) < (($153)>>>0); + if ($154) { __label__ = 29; break; } else { __label__ = 33; break; } + case 29: + var $156=$op; + var $157=$ri; + var $158=(($157+32)|0); + var $159=HEAP32[(($158)>>2)]; + var $160=(($159+($156<<3))|0); + var $161=(($160)|0); + var $162=HEAP32[(($161)>>2)]; + var $163=$old; + var $164=(($162)|0)==(($163)|0); + if ($164) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + var $166=$v; + var $167=$op; + var $168=$ri; + var $169=(($168+32)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=(($170+($167<<3))|0); + var $172=(($171)|0); + HEAP32[(($172)>>2)]=$166; + __label__ = 31; break; + case 31: + __label__ = 32; break; + case 32: + var $175=$op; + var $176=((($175)+(1))|0); + $op=$176; + __label__ = 28; break; + case 33: + $op=0; + __label__ = 34; break; + case 34: + var $179=$op; + var $180=(($179)>>>0) < 3; + if ($180) { __label__ = 35; break; } else { __label__ = 39; break; } + case 35: + var $182=$op; + var $183=$ri; + var $184=(($183+12)|0); + var $185=(($184+($182<<2))|0); + var $186=HEAP32[(($185)>>2)]; + var $187=$old; + var $188=(($186)|0)==(($187)|0); + if ($188) { __label__ = 36; break; } else { __label__ = 37; break; } + case 36: + var $190=$v; + var $191=$op; + var $192=$ri; + var $193=(($192+12)|0); + var $194=(($193+($191<<2))|0); + HEAP32[(($194)>>2)]=$190; + __label__ = 37; break; + case 37: + __label__ = 38; break; + case 38: + var $197=$op; + var $198=((($197)+(1))|0); + $op=$198; + __label__ = 34; break; + case 39: + __label__ = 40; break; + case 40: + var $201=$r; + var $202=((($201)+(1))|0); + $r=$202; + __label__ = 26; break; + case 41: + __label__ = 42; break; + case 42: + __label__ = 43; break; + case 43: + var $206=$w; + var $207=((($206)+(1))|0); + $w=$207; + __label__ = 11; break; + case 44: + __label__ = 45; break; + case 45: + var $210=$p; + var $211=((($210)+(1))|0); + $p=$211; + __label__ = 9; break; + case 46: + var $213=$instr; + _ir_instr_delete($213); + __label__ = 47; break; + case 47: + var $215=$i; + var $216=((($215)+(1))|0); + $i=$216; + __label__ = 3; break; + case 48: + $1=1; + __label__ = 49; break; + case 49: + var $219=$1; + ; + return $219; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_naive_phi["X"]=1; + +function _ir_block_life_propagate($self, $prev, $changed) { + var __stackBase__ = STACKTOP; STACKTOP += 28; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $instr; + var $value; + var $tempbool; + var $i; + var $o; + var $p; + var $read=__stackBase__; + var $write=(__stackBase__)+(4); + var $dbg_ind=(__stackBase__)+(8); + var $idx=(__stackBase__)+(24); + var $in_living; + var $entry; + $2=$self; + $3=$prev; + $4=$changed; + var $5=$dbg_ind; + assert(16 % 1 === 0, 'memcpy given ' + 16 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');for (var $$src = ((STRING_TABLE._ir_block_life_propagate_dbg_ind)|0), $$dest = $5, $$stop = $$src + 16; $$src < $$stop; $$src++, $$dest++) { + HEAP8[$$dest] = HEAP8[$$src] + }; + var $6=(($dbg_ind)|0); + var $7=$3; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $10=$2; + var $11=$3; + var $12=$4; + var $13=_ir_block_life_prop_previous($10, $11, $12); + if ($13) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 73; break; + case 5: + __label__ = 6; break; + case 6: + var $17=$2; + var $18=(($17+20)|0); + var $19=HEAP32[(($18)>>2)]; + $i=$19; + __label__ = 7; break; + case 7: + var $21=$i; + var $22=(($21)|0)!=0; + if ($22) { __label__ = 8; break; } else { __label__ = 66; break; } + case 8: + var $24=$i; + var $25=((($24)-(1))|0); + $i=$25; + var $26=$i; + var $27=$2; + var $28=(($27+16)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<2))|0); + var $31=HEAP32[(($30)>>2)]; + $instr=$31; + $p=0; + __label__ = 9; break; + case 9: + var $33=$p; + var $34=$instr; + var $35=(($34+36)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($33)>>>0) < (($36)>>>0); + if ($37) { __label__ = 10; break; } else { __label__ = 17; break; } + case 10: + var $39=$p; + var $40=$instr; + var $41=(($40+32)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=(($42+($39<<3))|0); + var $44=(($43)|0); + var $45=HEAP32[(($44)>>2)]; + $value=$45; + var $46=$value; + var $47=(($46+96)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48)|0)!=0; + if ($49) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $51=$value; + var $52=(($51+96)|0); + var $53=HEAP32[(($52)>>2)]; + $value=$53; + __label__ = 12; break; + case 12: + var $55=$2; + var $56=$value; + var $57=_ir_block_living_find($55, $56, 0); + if ($57) { __label__ = 15; break; } else { __label__ = 13; break; } + case 13: + var $59=$2; + var $60=$value; + var $61=_ir_block_living_add($59, $60); + if ($61) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + $1=0; + __label__ = 73; break; + case 15: + __label__ = 16; break; + case 16: + var $65=$p; + var $66=((($65)+(1))|0); + $p=$66; + __label__ = 9; break; + case 17: + $p=0; + __label__ = 18; break; + case 18: + var $69=$p; + var $70=$instr; + var $71=(($70+48)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=(($69)>>>0) < (($72)>>>0); + if ($73) { __label__ = 19; break; } else { __label__ = 26; break; } + case 19: + var $75=$p; + var $76=$instr; + var $77=(($76+44)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($78+($75<<2))|0); + var $80=HEAP32[(($79)>>2)]; + $value=$80; + var $81=$value; + var $82=(($81+96)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=(($83)|0)!=0; + if ($84) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + var $86=$value; + var $87=(($86+96)|0); + var $88=HEAP32[(($87)>>2)]; + $value=$88; + __label__ = 21; break; + case 21: + var $90=$2; + var $91=$value; + var $92=_ir_block_living_find($90, $91, 0); + if ($92) { __label__ = 24; break; } else { __label__ = 22; break; } + case 22: + var $94=$2; + var $95=$value; + var $96=_ir_block_living_add($94, $95); + if ($96) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + $1=0; + __label__ = 73; break; + case 24: + __label__ = 25; break; + case 25: + var $100=$p; + var $101=((($100)+(1))|0); + $p=$101; + __label__ = 18; break; + case 26: + var $103=$instr; + var $104=(($103)|0); + var $105=HEAP32[(($104)>>2)]; + _ir_op_read_write($105, $read, $write); + var $106=$instr; + var $107=(($106)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108)|0)==4; + if ($109) { __label__ = 27; break; } else { __label__ = 30; break; } + case 27: + var $111=$instr; + var $112=(($111+12)|0); + var $113=(($112+8)|0); + var $114=HEAP32[(($113)>>2)]; + var $115=$instr; + var $116=(($115+56)|0); + var $117=HEAP32[(($116)>>2)]; + var $118=((($117)+(1))|0); + var $119=_ir_value_life_merge($114, $118); + var $120=(($119)&1); + $tempbool=$120; + var $121=$4; + var $122=HEAP8[($121)]; + var $123=(($122) & 1); + if ($123) { var $128 = 1;__label__ = 29; break; } else { __label__ = 28; break; } + case 28: + var $125=$tempbool; + var $126=(($125) & 1); + var $128 = $126;__label__ = 29; break; + case 29: + var $128; + var $129=$4; + var $130=(($128)&1); + HEAP8[($129)]=$130; + __label__ = 35; break; + case 30: + var $132=$instr; + var $133=(($132)|0); + var $134=HEAP32[(($133)>>2)]; + var $135=(($134)|0)==3; + if ($135) { __label__ = 31; break; } else { __label__ = 34; break; } + case 31: + var $137=$instr; + var $138=(($137+12)|0); + var $139=(($138+4)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=$instr; + var $142=(($141+56)|0); + var $143=HEAP32[(($142)>>2)]; + var $144=((($143)+(1))|0); + var $145=_ir_value_life_merge($140, $144); + var $146=(($145)&1); + $tempbool=$146; + var $147=$4; + var $148=HEAP8[($147)]; + var $149=(($148) & 1); + if ($149) { var $154 = 1;__label__ = 33; break; } else { __label__ = 32; break; } + case 32: + var $151=$tempbool; + var $152=(($151) & 1); + var $154 = $152;__label__ = 33; break; + case 33: + var $154; + var $155=$4; + var $156=(($154)&1); + HEAP8[($155)]=$156; + __label__ = 34; break; + case 34: + __label__ = 35; break; + case 35: + $o=0; + __label__ = 36; break; + case 36: + var $160=$o; + var $161=(($160)>>>0) < 3; + if ($161) { __label__ = 37; break; } else { __label__ = 63; break; } + case 37: + var $163=$o; + var $164=$instr; + var $165=(($164+12)|0); + var $166=(($165+($163<<2))|0); + var $167=HEAP32[(($166)>>2)]; + var $168=(($167)|0)!=0; + if ($168) { __label__ = 39; break; } else { __label__ = 38; break; } + case 38: + __label__ = 62; break; + case 39: + var $171=$o; + var $172=$instr; + var $173=(($172+12)|0); + var $174=(($173+($171<<2))|0); + var $175=HEAP32[(($174)>>2)]; + $value=$175; + var $176=$value; + var $177=(($176+96)|0); + var $178=HEAP32[(($177)>>2)]; + var $179=(($178)|0)!=0; + if ($179) { __label__ = 40; break; } else { __label__ = 41; break; } + case 40: + var $181=$value; + var $182=(($181+96)|0); + var $183=HEAP32[(($182)>>2)]; + $value=$183; + __label__ = 41; break; + case 41: + var $185=$value; + var $186=(($185+8)|0); + var $187=HEAP32[(($186)>>2)]; + var $188=(($187)|0)!=3; + if ($188) { __label__ = 42; break; } else { __label__ = 45; break; } + case 42: + var $190=$value; + var $191=(($190+8)|0); + var $192=HEAP32[(($191)>>2)]; + var $193=(($192)|0)!=1; + if ($193) { __label__ = 43; break; } else { __label__ = 45; break; } + case 43: + var $195=$value; + var $196=(($195+8)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=(($197)|0)!=2; + if ($198) { __label__ = 44; break; } else { __label__ = 45; break; } + case 44: + __label__ = 62; break; + case 45: + var $201=HEAP32[(($read)>>2)]; + var $202=$o; + var $203=1 << $202; + var $204=$201 & $203; + var $205=(($204)|0)!=0; + if ($205) { __label__ = 46; break; } else { __label__ = 50; break; } + case 46: + var $207=$2; + var $208=$value; + var $209=_ir_block_living_find($207, $208, 0); + if ($209) { __label__ = 49; break; } else { __label__ = 47; break; } + case 47: + var $211=$2; + var $212=$value; + var $213=_ir_block_living_add($211, $212); + if ($213) { __label__ = 49; break; } else { __label__ = 48; break; } + case 48: + $1=0; + __label__ = 73; break; + case 49: + __label__ = 50; break; + case 50: + var $217=HEAP32[(($write)>>2)]; + var $218=$o; + var $219=1 << $218; + var $220=$217 & $219; + var $221=(($220)|0)!=0; + if ($221) { __label__ = 51; break; } else { __label__ = 61; break; } + case 51: + var $223=$2; + var $224=$value; + var $225=_ir_block_living_find($223, $224, $idx); + var $226=(($225)&1); + $in_living=$226; + var $227=$in_living; + var $228=(($227) & 1); + if ($228) { __label__ = 55; break; } else { __label__ = 52; break; } + case 52: + var $230=$value; + var $231=$instr; + var $232=(($231+56)|0); + var $233=HEAP32[(($232)>>2)]; + var $234=_ir_value_life_merge($230, $233); + var $235=(($234)&1); + $tempbool=$235; + var $236=$4; + var $237=HEAP8[($236)]; + var $238=(($237) & 1); + if ($238) { var $243 = 1;__label__ = 54; break; } else { __label__ = 53; break; } + case 53: + var $240=$tempbool; + var $241=(($240) & 1); + var $243 = $241;__label__ = 54; break; + case 54: + var $243; + var $244=$4; + var $245=(($243)&1); + HEAP8[($244)]=$245; + __label__ = 60; break; + case 55: + var $247=$value; + var $248=$instr; + var $249=(($248+56)|0); + var $250=HEAP32[(($249)>>2)]; + var $251=_ir_value_life_merge($247, $250); + var $252=(($251)&1); + $tempbool=$252; + var $253=$4; + var $254=HEAP8[($253)]; + var $255=(($254) & 1); + if ($255) { var $260 = 1;__label__ = 57; break; } else { __label__ = 56; break; } + case 56: + var $257=$tempbool; + var $258=(($257) & 1); + var $260 = $258;__label__ = 57; break; + case 57: + var $260; + var $261=$4; + var $262=(($260)&1); + HEAP8[($261)]=$262; + var $263=$2; + var $264=HEAP32[(($idx)>>2)]; + var $265=_ir_block_living_remove($263, $264); + if ($265) { __label__ = 59; break; } else { __label__ = 58; break; } + case 58: + $1=0; + __label__ = 73; break; + case 59: + __label__ = 60; break; + case 60: + __label__ = 61; break; + case 61: + __label__ = 62; break; + case 62: + var $271=$o; + var $272=((($271)+(1))|0); + $o=$272; + __label__ = 36; break; + case 63: + var $274=$2; + var $275=$instr; + var $276=(($275+56)|0); + var $277=HEAP32[(($276)>>2)]; + var $278=_ir_block_living_add_instr($274, $277); + var $279=(($278)&1); + $tempbool=$279; + var $280=$4; + var $281=HEAP8[($280)]; + var $282=(($281) & 1); + if ($282) { var $287 = 1;__label__ = 65; break; } else { __label__ = 64; break; } + case 64: + var $284=$tempbool; + var $285=(($284) & 1); + var $287 = $285;__label__ = 65; break; + case 65: + var $287; + var $288=$4; + var $289=(($287)&1); + HEAP8[($288)]=$289; + __label__ = 7; break; + case 66: + var $291=$2; + var $292=(($291+72)|0); + var $293=HEAP32[(($292)>>2)]; + var $294=$2; + var $295=(($294+76)|0); + var $296=HEAP32[(($295)>>2)]; + var $297=(($296+88)|0); + var $298=HEAP32[(($297)>>2)]; + var $299=(($293)|0)==(($298)|0); + if ($299) { __label__ = 67; break; } else { __label__ = 68; break; } + case 67: + $1=1; + __label__ = 73; break; + case 68: + var $302=$2; + var $303=(($302+76)|0); + var $304=HEAP32[(($303)>>2)]; + var $305=(($304+88)|0); + var $306=HEAP32[(($305)>>2)]; + var $307=$2; + var $308=(($307+72)|0); + HEAP32[(($308)>>2)]=$306; + $i=0; + __label__ = 69; break; + case 69: + var $310=$i; + var $311=$2; + var $312=(($311+32)|0); + var $313=HEAP32[(($312)>>2)]; + var $314=(($310)>>>0) < (($313)>>>0); + if ($314) { __label__ = 70; break; } else { __label__ = 72; break; } + case 70: + var $316=$i; + var $317=$2; + var $318=(($317+28)|0); + var $319=HEAP32[(($318)>>2)]; + var $320=(($319+($316<<2))|0); + var $321=HEAP32[(($320)>>2)]; + $entry=$321; + var $322=$entry; + var $323=$2; + var $324=$4; + var $325=_ir_block_life_propagate($322, $323, $324); + __label__ = 71; break; + case 71: + var $327=$i; + var $328=((($327)+(1))|0); + $i=$328; + __label__ = 69; break; + case 72: + $1=1; + __label__ = 73; break; + case 73: + var $331=$1; + STACKTOP = __stackBase__; + return $331; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_life_propagate["X"]=1; + +function _irwarning($ctx_0, $ctx_1, $warntype, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $ap=(__stackBase__)+(8); + var $lvl; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$warntype; + $3=$fmt; + $lvl=1; + var $6=$2; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $9=$2; + var $10=((((($9)|0))/(32))&-1); + var $11=((_opts_warn+($10<<2))|0); + var $12=HEAP32[(($11)>>2)]; + var $13=$2; + var $14=((($13)|0))%(32); + var $15=1 << $14; + var $16=$12 & $15; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 8; break; + case 5: + var $20=HEAP8[(_opts_werror)]; + var $21=(($20) & 1); + if ($21) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + $lvl=2; + __label__ = 7; break; + case 7: + var $24=$ap; + HEAP32[(($24)>>2)]=arguments[_irwarning.length]; + var $25=$lvl; + var $26=(($ctx)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($ctx+4)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=$3; + var $31=HEAP32[(($ap)>>2)]; + _vprintmsg($25, $27, $29, ((STRING_TABLE.__str85299)|0), $30, $31); + var $32=$ap; + ; + var $33=HEAP8[(_opts_werror)]; + var $34=(($33) & 1); + $1=$34; + __label__ = 8; break; + case 8: + var $36=$1; + STACKTOP = __stackBase__; + return $36; + default: assert(0, "bad label: " + __label__); + } +} +_irwarning["X"]=1; + +function _function_allocator_locals_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+8)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+8)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+8)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+8)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+8)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 1925, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+4)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 1925, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+4)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_function_allocator_locals_add["X"]=1; + +function _function_allocator_sizes_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+16)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+20)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+20)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+20)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+20)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 1926, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+12)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+16)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+12)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 1926, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+12)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+16)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+12)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_function_allocator_sizes_add["X"]=1; + +function _function_allocator_positions_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+28)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+32)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+32)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+32)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+32)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+32)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 1927, ((STRING_TABLE.__str9222)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+24)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+28)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+24)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 1927, ((STRING_TABLE.__str9222)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+24)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+28)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+24)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_function_allocator_positions_add["X"]=1; + +function _function_allocator_alloc($alloc, $var) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $slot; + var $vsize; + $2=$alloc; + $3=$var; + var $4=$3; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=((_type_sizeof+($6<<2))|0); + var $8=HEAP32[(($7)>>2)]; + $vsize=$8; + var $9=$3; + var $10=(($9+4)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=_ir_value_var(((STRING_TABLE.__str84298)|0), 0, $11); + $slot=$12; + var $13=$slot; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 12; break; + case 4: + var $17=$slot; + var $18=$3; + var $19=_ir_value_life_merge_into($17, $18); + if ($19) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + __label__ = 11; break; + case 6: + var $22=$2; + var $23=$slot; + var $24=_function_allocator_locals_add($22, $23); + if ($24) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + __label__ = 11; break; + case 8: + var $27=$2; + var $28=$vsize; + var $29=_function_allocator_sizes_add($27, $28); + if ($29) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + __label__ = 11; break; + case 10: + $1=1; + __label__ = 12; break; + case 11: + var $33=$slot; + _ir_value_delete($33); + $1=0; + __label__ = 12; break; + case 12: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_builder_generate($self, $filename) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $stmt=__stackBase__; + var $i; + $2=$self; + $3=$filename; + _code_init(); + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+20)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$2; + var $12=$i; + var $13=$2; + var $14=(($13+16)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=HEAP32[(($16)>>2)]; + var $18=_ir_builder_gen_global($11, $17, 0); + if ($18) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 25; break; + case 6: + __label__ = 7; break; + case 7: + var $22=$i; + var $23=((($22)+(1))|0); + $i=$23; + __label__ = 3; break; + case 8: + $i=0; + __label__ = 9; break; + case 9: + var $26=$i; + var $27=$2; + var $28=(($27+32)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($26)>>>0) < (($29)>>>0); + if ($30) { __label__ = 10; break; } else { __label__ = 14; break; } + case 10: + var $32=$2; + var $33=$i; + var $34=$2; + var $35=(($34+28)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36+($33<<2))|0); + var $38=HEAP32[(($37)>>2)]; + var $39=_ir_builder_gen_field($32, $38); + if ($39) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=0; + __label__ = 25; break; + case 12: + __label__ = 13; break; + case 13: + var $43=$i; + var $44=((($43)+(1))|0); + $i=$44; + __label__ = 9; break; + case 14: + $i=0; + __label__ = 15; break; + case 15: + var $47=$i; + var $48=$2; + var $49=(($48+20)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($47)>>>0) < (($50)>>>0); + if ($51) { __label__ = 16; break; } else { __label__ = 22; break; } + case 16: + var $53=$i; + var $54=$2; + var $55=(($54+16)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+($53<<2))|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+4)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60)|0)==6; + if ($61) { __label__ = 17; break; } else { __label__ = 20; break; } + case 17: + var $63=$2; + var $64=$i; + var $65=$2; + var $66=(($65+16)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=(($67+($64<<2))|0); + var $69=HEAP32[(($68)>>2)]; + var $70=_gen_global_function_code($63, $69); + if ($70) { __label__ = 19; break; } else { __label__ = 18; break; } + case 18: + $1=0; + __label__ = 25; break; + case 19: + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + var $75=$i; + var $76=((($75)+(1))|0); + $i=$76; + __label__ = 15; break; + case 22: + var $78=(($stmt)|0); + HEAP16[(($78)>>1)]=0; + var $79=(($stmt+2)|0); + var $80=$79; + HEAP16[(($80)>>1)]=0; + var $81=(($stmt+4)|0); + var $82=$81; + HEAP16[(($82)>>1)]=0; + var $83=(($stmt+6)|0); + var $84=$83; + HEAP16[(($84)>>1)]=0; + var $85=_code_statements_add($stmt); + var $86=(($85)|0) < 0; + if ($86) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + $1=0; + __label__ = 25; break; + case 24: + var $89=$3; + var $90=_printf(((STRING_TABLE.__str21235)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$89,tempInt)); + var $91=$3; + var $92=_code_write($91); + $1=$92; + __label__ = 25; break; + case 25: + var $94=$1; + STACKTOP = __stackBase__; + return $94; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_generate["X"]=1; + +function _ir_builder_gen_global($self, $global, $islocal) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + var $iptr; + var $def=__stackBase__; + var $d; + $2=$self; + $3=$global; + var $5=(($islocal)&1); + $4=$5; + var $6=$3; + var $7=(($6+4)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8) & 65535); + var $10=(($def)|0); + HEAP16[(($10)>>1)]=$9; + var $11=HEAP32[((_code_globals_elements)>>2)]; + var $12=(($11) & 65535); + var $13=(($def+2)|0); + HEAP16[(($13)>>1)]=$12; + var $14=$3; + var $15=(($14)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $19=$3; + var $20=(($19)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0); + var $23=HEAP8[($22)]; + var $24=(($23 << 24) >> 24); + var $25=(($24)|0)==35; + if ($25) { __label__ = 4; break; } else { __label__ = 7; break; } + case 4: + var $27=$2; + var $28=(($27+64)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $32=_code_genstring(((STRING_TABLE.__str74288)|0)); + var $33=$2; + var $34=(($33+64)|0); + HEAP32[(($34)>>2)]=$32; + __label__ = 6; break; + case 6: + var $36=$2; + var $37=(($36+64)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$3; + var $40=(($39+68)|0); + var $41=(($40+4)|0); + HEAP32[(($41)>>2)]=$38; + var $42=(($def+4)|0); + HEAP32[(($42)>>2)]=$38; + __label__ = 8; break; + case 7: + var $44=$3; + var $45=(($44)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=_code_genstring($46); + var $48=$3; + var $49=(($48+68)|0); + var $50=(($49+4)|0); + HEAP32[(($50)>>2)]=$47; + var $51=(($def+4)|0); + HEAP32[(($51)>>2)]=$47; + __label__ = 8; break; + case 8: + __label__ = 10; break; + case 9: + var $54=(($def+4)|0); + HEAP32[(($54)>>2)]=0; + __label__ = 10; break; + case 10: + var $56=$3; + var $57=(($56+4)|0); + var $58=HEAP32[(($57)>>2)]; + if ((($58)|0) == 0) { + __label__ = 11; break; + } + else if ((($58)|0) == 7) { + __label__ = 20; break; + } + else if ((($58)|0) == 5) { + __label__ = 23; break; + } + else if ((($58)|0) == 4 || (($58)|0) == 2) { + __label__ = 26; break; + } + else if ((($58)|0) == 1) { + __label__ = 34; break; + } + else if ((($58)|0) == 3) { + __label__ = 42; break; + } + else if ((($58)|0) == 6) { + __label__ = 66; break; + } + else if ((($58)|0) == 9) { + __label__ = 78; break; + } + else { + __label__ = 83; break; + } + + case 11: + var $60=$3; + var $61=(($60)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=_strcmp($62, ((STRING_TABLE.__str75289)|0)); + var $64=(($63)|0)!=0; + if ($64) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + __label__ = 17; break; + case 13: + var $67=$3; + var $68=(($67)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=_strcmp($69, ((STRING_TABLE.__str76290)|0)); + var $71=(($70)|0)!=0; + if ($71) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + __label__ = 16; break; + case 15: + var $74=$3; + var $75=(($74+12)|0); + var $76=$3; + var $77=(($76)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($75)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=(($75+4)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=_irwarning($80, $82, 10, ((STRING_TABLE.__str77291)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$78,tempInt)); + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + var $86=$3; + var $87=_code_globals_add(0); + _ir_value_code_setaddr($86, $87); + var $88=_code_defs_add($def); + var $89=(($88)|0) < 0; + if ($89) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + $1=0; + __label__ = 84; break; + case 19: + $1=1; + __label__ = 84; break; + case 20: + var $93=_code_defs_add($def); + var $94=(($93)|0) < 0; + if ($94) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + $1=0; + __label__ = 84; break; + case 22: + var $97=$3; + var $98=_gen_global_pointer($97); + $1=$98; + __label__ = 84; break; + case 23: + var $100=_code_defs_add($def); + var $101=(($100)|0) < 0; + if ($101) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + $1=0; + __label__ = 84; break; + case 25: + var $104=$3; + var $105=_gen_global_field($104); + $1=$105; + __label__ = 84; break; + case 26: + var $107=$3; + var $108=(($107+52)|0); + var $109=HEAP8[($108)]; + var $110=(($109) & 1); + if ($110) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + var $112=$3; + var $113=(($112+56)|0); + var $114=$113; + var $115=(($114)|0); + $iptr=$115; + var $116=$3; + var $117=$iptr; + var $118=HEAP32[(($117)>>2)]; + var $119=_code_globals_add($118); + _ir_value_code_setaddr($116, $119); + __label__ = 31; break; + case 28: + var $121=$3; + var $122=_code_globals_add(0); + _ir_value_code_setaddr($121, $122); + var $123=$4; + var $124=(($123) & 1); + if ($124) { __label__ = 30; break; } else { __label__ = 29; break; } + case 29: + var $126=(($def)|0); + var $127=HEAP16[(($126)>>1)]; + var $128=(($127)&65535); + var $129=$128 | 32768; + var $130=(($129) & 65535); + HEAP16[(($126)>>1)]=$130; + __label__ = 30; break; + case 30: + __label__ = 31; break; + case 31: + var $133=_code_defs_add($def); + var $134=(($133)|0) < 0; + if ($134) { __label__ = 32; break; } else { __label__ = 33; break; } + case 32: + $1=0; + __label__ = 84; break; + case 33: + var $137=$3; + var $138=(($137+68)|0); + var $139=(($138)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=(($140)|0) >= 0; + $1=$141; + __label__ = 84; break; + case 34: + var $143=$3; + var $144=(($143+52)|0); + var $145=HEAP8[($144)]; + var $146=(($145) & 1); + if ($146) { __label__ = 35; break; } else { __label__ = 36; break; } + case 35: + var $148=$3; + var $149=$3; + var $150=(($149+56)|0); + var $151=$150; + var $152=HEAP32[(($151)>>2)]; + var $153=_code_genstring($152); + var $154=_code_globals_add($153); + _ir_value_code_setaddr($148, $154); + __label__ = 39; break; + case 36: + var $156=$3; + var $157=_code_globals_add(0); + _ir_value_code_setaddr($156, $157); + var $158=$4; + var $159=(($158) & 1); + if ($159) { __label__ = 38; break; } else { __label__ = 37; break; } + case 37: + var $161=(($def)|0); + var $162=HEAP16[(($161)>>1)]; + var $163=(($162)&65535); + var $164=$163 | 32768; + var $165=(($164) & 65535); + HEAP16[(($161)>>1)]=$165; + __label__ = 38; break; + case 38: + __label__ = 39; break; + case 39: + var $168=_code_defs_add($def); + var $169=(($168)|0) < 0; + if ($169) { __label__ = 40; break; } else { __label__ = 41; break; } + case 40: + $1=0; + __label__ = 84; break; + case 41: + var $172=$3; + var $173=(($172+68)|0); + var $174=(($173)|0); + var $175=HEAP32[(($174)>>2)]; + var $176=(($175)|0) >= 0; + $1=$176; + __label__ = 84; break; + case 42: + var $178=$3; + var $179=(($178+52)|0); + var $180=HEAP8[($179)]; + var $181=(($180) & 1); + if ($181) { __label__ = 43; break; } else { __label__ = 52; break; } + case 43: + var $183=$3; + var $184=(($183+56)|0); + var $185=$184; + var $186=(($185)|0); + $iptr=$186; + var $187=$3; + var $188=$iptr; + var $189=(($188)|0); + var $190=HEAP32[(($189)>>2)]; + var $191=_code_globals_add($190); + _ir_value_code_setaddr($187, $191); + var $192=$3; + var $193=(($192+68)|0); + var $194=(($193)|0); + var $195=HEAP32[(($194)>>2)]; + var $196=(($195)|0) < 0; + if ($196) { __label__ = 44; break; } else { __label__ = 45; break; } + case 44: + $1=0; + __label__ = 84; break; + case 45: + $d=1; + __label__ = 46; break; + case 46: + var $200=$d; + var $201=$3; + var $202=(($201+4)|0); + var $203=HEAP32[(($202)>>2)]; + var $204=((_type_sizeof+($203<<2))|0); + var $205=HEAP32[(($204)>>2)]; + var $206=(($200)>>>0) < (($205)>>>0); + if ($206) { __label__ = 47; break; } else { __label__ = 51; break; } + case 47: + var $208=$d; + var $209=$iptr; + var $210=(($209+($208<<2))|0); + var $211=HEAP32[(($210)>>2)]; + var $212=_code_globals_add($211); + var $213=(($212)|0) < 0; + if ($213) { __label__ = 48; break; } else { __label__ = 49; break; } + case 48: + $1=0; + __label__ = 84; break; + case 49: + __label__ = 50; break; + case 50: + var $217=$d; + var $218=((($217)+(1))|0); + $d=$218; + __label__ = 46; break; + case 51: + __label__ = 63; break; + case 52: + var $221=$3; + var $222=_code_globals_add(0); + _ir_value_code_setaddr($221, $222); + var $223=$3; + var $224=(($223+68)|0); + var $225=(($224)|0); + var $226=HEAP32[(($225)>>2)]; + var $227=(($226)|0) < 0; + if ($227) { __label__ = 53; break; } else { __label__ = 54; break; } + case 53: + $1=0; + __label__ = 84; break; + case 54: + $d=1; + __label__ = 55; break; + case 55: + var $231=$d; + var $232=$3; + var $233=(($232+4)|0); + var $234=HEAP32[(($233)>>2)]; + var $235=((_type_sizeof+($234<<2))|0); + var $236=HEAP32[(($235)>>2)]; + var $237=(($231)>>>0) < (($236)>>>0); + if ($237) { __label__ = 56; break; } else { __label__ = 60; break; } + case 56: + var $239=_code_globals_add(0); + var $240=(($239)|0) < 0; + if ($240) { __label__ = 57; break; } else { __label__ = 58; break; } + case 57: + $1=0; + __label__ = 84; break; + case 58: + __label__ = 59; break; + case 59: + var $244=$d; + var $245=((($244)+(1))|0); + $d=$245; + __label__ = 55; break; + case 60: + var $247=$4; + var $248=(($247) & 1); + if ($248) { __label__ = 62; break; } else { __label__ = 61; break; } + case 61: + var $250=(($def)|0); + var $251=HEAP16[(($250)>>1)]; + var $252=(($251)&65535); + var $253=$252 | 32768; + var $254=(($253) & 65535); + HEAP16[(($250)>>1)]=$254; + __label__ = 62; break; + case 62: + __label__ = 63; break; + case 63: + var $257=_code_defs_add($def); + var $258=(($257)|0) < 0; + if ($258) { __label__ = 64; break; } else { __label__ = 65; break; } + case 64: + $1=0; + __label__ = 84; break; + case 65: + var $261=$3; + var $262=(($261+68)|0); + var $263=(($262)|0); + var $264=HEAP32[(($263)>>2)]; + var $265=(($264)|0) >= 0; + $1=$265; + __label__ = 84; break; + case 66: + var $267=$3; + var $268=(($267+52)|0); + var $269=HEAP8[($268)]; + var $270=(($269) & 1); + if ($270) { __label__ = 70; break; } else { __label__ = 67; break; } + case 67: + var $272=$3; + var $273=_code_globals_add(0); + _ir_value_code_setaddr($272, $273); + var $274=$3; + var $275=(($274+68)|0); + var $276=(($275)|0); + var $277=HEAP32[(($276)>>2)]; + var $278=(($277)|0) < 0; + if ($278) { __label__ = 68; break; } else { __label__ = 69; break; } + case 68: + $1=0; + __label__ = 84; break; + case 69: + __label__ = 75; break; + case 70: + var $282=$3; + var $283=HEAP32[((_code_globals_elements)>>2)]; + _ir_value_code_setaddr($282, $283); + var $284=HEAP32[((_code_functions_elements)>>2)]; + var $285=_code_globals_add($284); + var $286=$2; + var $287=$3; + var $288=_gen_global_function($286, $287); + if ($288) { __label__ = 72; break; } else { __label__ = 71; break; } + case 71: + $1=0; + __label__ = 84; break; + case 72: + var $291=$4; + var $292=(($291) & 1); + if ($292) { __label__ = 74; break; } else { __label__ = 73; break; } + case 73: + var $294=(($def)|0); + var $295=HEAP16[(($294)>>1)]; + var $296=(($295)&65535); + var $297=$296 | 32768; + var $298=(($297) & 65535); + HEAP16[(($294)>>1)]=$298; + __label__ = 74; break; + case 74: + __label__ = 75; break; + case 75: + var $301=_code_defs_add($def); + var $302=(($301)|0) < 0; + if ($302) { __label__ = 76; break; } else { __label__ = 77; break; } + case 76: + $1=0; + __label__ = 84; break; + case 77: + $1=1; + __label__ = 84; break; + case 78: + var $306=$3; + var $307=_code_globals_add(0); + _ir_value_code_setaddr($306, $307); + $i=1; + __label__ = 79; break; + case 79: + var $309=$i; + var $310=HEAP32[((((_type_sizeof+36)|0))>>2)]; + var $311=(($309)>>>0) < (($310)>>>0); + if ($311) { __label__ = 80; break; } else { __label__ = 82; break; } + case 80: + var $313=_code_globals_add(0); + __label__ = 81; break; + case 81: + var $315=$i; + var $316=((($315)+(1))|0); + $i=$316; + __label__ = 79; break; + case 82: + $1=1; + __label__ = 84; break; + case 83: + var $319=$3; + var $320=(($319+12)|0); + var $321=$3; + var $322=(($321)|0); + var $323=HEAP32[(($322)>>2)]; + var $324=$3; + var $325=(($324+4)|0); + var $326=HEAP32[(($325)>>2)]; + var $327=((_type_name+($326<<2))|0); + var $328=HEAP32[(($327)>>2)]; + var $329=(($320)|0); + var $330=HEAP32[(($329)>>2)]; + var $331=(($320+4)|0); + var $332=HEAP32[(($331)>>2)]; + _irerror($330, $332, ((STRING_TABLE.__str78292)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$323,HEAP32[(((tempInt)+(4))>>2)]=$328,tempInt)); + $1=0; + __label__ = 84; break; + case 84: + var $334=$1; + STACKTOP = __stackBase__; + return $334; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_gen_global["X"]=1; + +function _ir_builder_gen_field($self, $field) { + var __stackBase__ = STACKTOP; STACKTOP += 1040; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $def=__stackBase__; + var $fld=(__stackBase__)+(8); + var $len; + var $name=(__stackBase__)+(16); + $2=$self; + $3=$field; + var $4=$3; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6) & 65535); + var $8=(($def)|0); + HEAP16[(($8)>>1)]=$7; + var $9=HEAP32[((_code_globals_elements)>>2)]; + var $10=(($9) & 65535); + var $11=(($def+2)|0); + HEAP16[(($11)>>1)]=$10; + var $12=HEAP32[((_opts_standard)>>2)]; + var $13=(($12)|0)==3; + if ($13) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $15=$3; + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=_strlen($17); + $len=$18; + var $19=$len; + var $20=((($19)+(2))|0); + var $21=(($20)>>>0) >= 1024; + if ($21) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $23=$3; + var $24=(($23+12)|0); + var $25=$len; + var $26=(($24)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($24+4)|0); + var $29=HEAP32[(($28)>>2)]; + _irerror($27, $29, ((STRING_TABLE.__str72286)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$25,tempInt)); + $1=0; + __label__ = 22; break; + case 5: + var $31=(($name)|0); + HEAP8[($31)]=46; + var $32=(($name)|0); + var $33=(($32+1)|0); + var $34=$3; + var $35=(($34)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=$len; + assert($37 % 1 === 0, 'memcpy given ' + $37 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($33, $36, $37, 1); + var $38=$len; + var $39=((($38)+(1))|0); + var $40=(($name+$39)|0); + HEAP8[($40)]=0; + var $41=(($name)|0); + var $42=_code_genstring($41); + var $43=(($def+4)|0); + HEAP32[(($43)>>2)]=$42; + var $44=(($def+4)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=((($45)+(1))|0); + var $47=(($fld+4)|0); + HEAP32[(($47)>>2)]=$46; + __label__ = 7; break; + case 6: + var $49=$3; + var $50=(($49)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=_code_genstring($51); + var $53=(($def+4)|0); + HEAP32[(($53)>>2)]=$52; + var $54=(($def+4)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($fld+4)|0); + HEAP32[(($56)>>2)]=$55; + __label__ = 7; break; + case 7: + var $58=(($def+4)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=$3; + var $61=(($60+68)|0); + var $62=(($61+4)|0); + HEAP32[(($62)>>2)]=$59; + var $63=_code_defs_add($def); + var $64=(($63)|0) < 0; + if ($64) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + $1=0; + __label__ = 22; break; + case 9: + var $67=$3; + var $68=(($67+20)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=(($69) & 65535); + var $71=(($fld)|0); + HEAP16[(($71)>>1)]=$70; + var $72=(($fld)|0); + var $73=HEAP16[(($72)>>1)]; + var $74=(($73)&65535); + var $75=(($74)|0)==0; + if ($75) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $77=$3; + var $78=(($77+12)|0); + var $79=$3; + var $80=(($79)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($78)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=(($78+4)|0); + var $85=HEAP32[(($84)>>2)]; + _irerror($83, $85, ((STRING_TABLE.__str73287)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$81,tempInt)); + $1=0; + __label__ = 22; break; + case 11: + var $87=$3; + var $88=(($87+20)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=((_type_sizeof+($89<<2))|0); + var $91=HEAP32[(($90)>>2)]; + var $92=_code_alloc_field($91); + var $93=(($92) & 65535); + var $94=(($fld+2)|0); + HEAP16[(($94)>>1)]=$93; + var $95=_code_fields_add($fld); + var $96=(($95)|0) < 0; + if ($96) { __label__ = 12; break; } else { __label__ = 13; break; } + case 12: + $1=0; + __label__ = 22; break; + case 13: + var $99=$3; + var $100=HEAP32[((_code_globals_elements)>>2)]; + _ir_value_code_setaddr($99, $100); + var $101=(($fld+2)|0); + var $102=HEAP16[(($101)>>1)]; + var $103=(($102)&65535); + var $104=_code_globals_add($103); + var $105=(($104)|0)!=0; + if ($105) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + $1=0; + __label__ = 22; break; + case 15: + var $108=(($fld)|0); + var $109=HEAP16[(($108)>>1)]; + var $110=(($109)&65535); + var $111=(($110)|0)==3; + if ($111) { __label__ = 16; break; } else { __label__ = 21; break; } + case 16: + var $113=(($fld+2)|0); + var $114=HEAP16[(($113)>>1)]; + var $115=(($114)&65535); + var $116=((($115)+(1))|0); + var $117=_code_globals_add($116); + var $118=(($117)|0)!=0; + if ($118) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=0; + __label__ = 22; break; + case 18: + var $121=(($fld+2)|0); + var $122=HEAP16[(($121)>>1)]; + var $123=(($122)&65535); + var $124=((($123)+(2))|0); + var $125=_code_globals_add($124); + var $126=(($125)|0)!=0; + if ($126) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + $1=0; + __label__ = 22; break; + case 20: + __label__ = 21; break; + case 21: + var $130=$3; + var $131=(($130+68)|0); + var $132=(($131)|0); + var $133=HEAP32[(($132)>>2)]; + var $134=(($133)|0) >= 0; + $1=$134; + __label__ = 22; break; + case 22: + var $136=$1; + STACKTOP = __stackBase__; + return $136; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_gen_field["X"]=1; + +function _qc_opname($op) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$op; + var $3=$2; + var $4=(($3)|0) < 0; + if ($4) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=((STRING_TABLE.__str22236)|0); + __label__ = 11; break; + case 4: + var $7=$2; + var $8=(($7)>>>0) < 67; + if ($8) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $10=$2; + var $11=((_asm_instr231+($10)*(12))|0); + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + $1=$13; + __label__ = 11; break; + case 6: + var $15=$2; + if ((($15)|0) == 67) { + __label__ = 7; break; + } + else if ((($15)|0) == 68) { + __label__ = 8; break; + } + else if ((($15)|0) == 69) { + __label__ = 9; break; + } + else { + __label__ = 10; break; + } + + case 7: + $1=((STRING_TABLE.__str23237)|0); + __label__ = 11; break; + case 8: + $1=((STRING_TABLE.__str24238)|0); + __label__ = 11; break; + case 9: + $1=((STRING_TABLE.__str25239)|0); + __label__ = 11; break; + case 10: + $1=((STRING_TABLE.__str26240)|0); + __label__ = 11; break; + case 11: + var $21=$1; + ; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _gen_global_function_code($ir, $global) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $fundef; + var $irfun; + $2=$ir; + $3=$global; + var $4=$3; + var $5=(($4+56)|0); + var $6=$5; + var $7=HEAP32[(($6)>>2)]; + $irfun=$7; + var $8=$irfun; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $11=$3; + var $12=(($11+12)|0); + var $13=$3; + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($12+4)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=_irwarning($17, $19, 11, ((STRING_TABLE.__str65279)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$15,tempInt)); + $1=1; + __label__ = 11; break; + case 4: + var $22=$irfun; + var $23=(($22+32)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=1; + __label__ = 11; break; + case 6: + var $28=$irfun; + var $29=(($28+84)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0) < 0; + if ($31) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $33=$irfun; + var $34=(($33+76)|0); + var $35=$irfun; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($34)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($34+4)|0); + var $41=HEAP32[(($40)>>2)]; + _irerror($39, $41, ((STRING_TABLE.__str66280)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$37,tempInt)); + $1=0; + __label__ = 11; break; + case 8: + var $43=$irfun; + var $44=(($43+84)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=HEAP32[((_code_functions_data)>>2)]; + var $47=(($46+($45)*(36))|0); + $fundef=$47; + var $48=HEAP32[((_code_statements_elements)>>2)]; + var $49=$fundef; + var $50=(($49)|0); + HEAP32[(($50)>>2)]=$48; + var $51=$irfun; + var $52=_gen_function_code($51); + if ($52) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $54=$irfun; + var $55=(($54+76)|0); + var $56=$irfun; + var $57=(($56)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($55)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($55+4)|0); + var $62=HEAP32[(($61)>>2)]; + _irerror($60, $62, ((STRING_TABLE.__str67281)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$58,tempInt)); + $1=0; + __label__ = 11; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_gen_global_function_code["X"]=1; + +function _ir_builder_dump($b, $oprintf) { + var __stackBase__ = STACKTOP; STACKTOP += 1024; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $indent=__stackBase__; + $1=$b; + $2=$oprintf; + var $3=(($indent)|0); + HEAP8[($3)]=9; + var $4=(($indent+1)|0); + HEAP8[($4)]=0; + var $5=$2; + var $6=$1; + var $7=(($6)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=FUNCTION_TABLE[$5](((STRING_TABLE.__str27241)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8,tempInt)); + $i=0; + __label__ = 3; break; + case 3: + var $11=$i; + var $12=$1; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($11)>>>0) < (($14)>>>0); + if ($15) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $17=$2; + var $18=FUNCTION_TABLE[$17](((STRING_TABLE.__str28242)|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)); + var $19=$i; + var $20=$1; + var $21=(($20+16)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22+($19<<2))|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+52)|0); + var $26=HEAP8[($25)]; + var $27=(($26) & 1); + if ($27) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $29=$2; + var $30=$i; + var $31=$1; + var $32=(($31+16)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33+($30<<2))|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=FUNCTION_TABLE[$29](((STRING_TABLE.__str29243)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$37,tempInt)); + __label__ = 6; break; + case 6: + var $40=$i; + var $41=$1; + var $42=(($41+16)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($43+($40<<2))|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$2; + _ir_value_dump($45, $46); + var $47=$2; + var $48=FUNCTION_TABLE[$47](((STRING_TABLE.__str30244)|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)); + __label__ = 7; break; + case 7: + var $50=$i; + var $51=((($50)+(1))|0); + $i=$51; + __label__ = 3; break; + case 8: + $i=0; + __label__ = 9; break; + case 9: + var $54=$i; + var $55=$1; + var $56=(($55+8)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=(($54)>>>0) < (($57)>>>0); + if ($58) { __label__ = 10; break; } else { __label__ = 12; break; } + case 10: + var $60=$i; + var $61=$1; + var $62=(($61+4)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63+($60<<2))|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($indent)|0); + var $67=$2; + _ir_function_dump($65, $66, $67); + __label__ = 11; break; + case 11: + var $69=$i; + var $70=((($69)+(1))|0); + $i=$70; + __label__ = 9; break; + case 12: + var $72=$2; + var $73=$1; + var $74=(($73)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=FUNCTION_TABLE[$72](((STRING_TABLE.__str31245)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$75,tempInt)); + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_dump["X"]=1; + +function _ir_value_dump($v, $oprintf) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$v; + $2=$oprintf; + var $3=$1; + var $4=(($3+52)|0); + var $5=HEAP8[($4)]; + var $6=(($5) & 1); + if ($6) { __label__ = 3; break; } else { __label__ = 13; break; } + case 3: + var $8=$1; + var $9=(($8+4)|0); + var $10=HEAP32[(($9)>>2)]; + if ((($10)|0) == 0) { + __label__ = 5; break; + } + else if ((($10)|0) == 6) { + __label__ = 6; break; + } + else if ((($10)|0) == 2) { + __label__ = 7; break; + } + else if ((($10)|0) == 3) { + __label__ = 8; break; + } + else if ((($10)|0) == 4) { + __label__ = 9; break; + } + else if ((($10)|0) == 1) { + __label__ = 10; break; + } + else if ((($10)|0) == 7) { + __label__ = 11; break; + } + else { + __label__ = 4; break; + } + + case 4: + __label__ = 5; break; + case 5: + var $13=$2; + var $14=FUNCTION_TABLE[$13](((STRING_TABLE.__str55269)|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)); + __label__ = 12; break; + case 6: + var $16=$2; + var $17=$1; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=FUNCTION_TABLE[$16](((STRING_TABLE.__str56270)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$19,tempInt)); + __label__ = 12; break; + case 7: + var $22=$2; + var $23=$1; + var $24=(($23+56)|0); + var $25=$24; + var $26=HEAPF32[(($25)>>2)]; + var $27=$26; + var $28=FUNCTION_TABLE[$22](((STRING_TABLE.__str57271)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),(tempDoubleF64[0]=$27,HEAP32[((tempInt)>>2)]=tempDoubleI32[0],HEAP32[(((tempInt)+(4))>>2)]=tempDoubleI32[1]),tempInt)); + __label__ = 12; break; + case 8: + var $30=$2; + var $31=$1; + var $32=(($31+56)|0); + var $33=$32; + var $34=(($33)|0); + var $35=HEAPF32[(($34)>>2)]; + var $36=$35; + var $37=$1; + var $38=(($37+56)|0); + var $39=$38; + var $40=(($39+4)|0); + var $41=HEAPF32[(($40)>>2)]; + var $42=$41; + var $43=$1; + var $44=(($43+56)|0); + var $45=$44; + var $46=(($45+8)|0); + var $47=HEAPF32[(($46)>>2)]; + var $48=$47; + var $49=FUNCTION_TABLE[$30](((STRING_TABLE.__str58272)|0), (tempInt=STACKTOP,STACKTOP += 24,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),(tempDoubleF64[0]=$36,HEAP32[((tempInt)>>2)]=tempDoubleI32[0],HEAP32[(((tempInt)+(4))>>2)]=tempDoubleI32[1]),(tempDoubleF64[0]=$42,HEAP32[(((tempInt)+(8))>>2)]=tempDoubleI32[0],HEAP32[((((tempInt)+(8))+(4))>>2)]=tempDoubleI32[1]),(tempDoubleF64[0]=$48,HEAP32[(((tempInt)+(16))>>2)]=tempDoubleI32[0],HEAP32[((((tempInt)+(16))+(4))>>2)]=tempDoubleI32[1]),tempInt)); + __label__ = 12; break; + case 9: + var $51=$2; + var $52=FUNCTION_TABLE[$51](((STRING_TABLE.__str59273)|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)); + __label__ = 12; break; + case 10: + var $54=$2; + var $55=$1; + var $56=(($55+56)|0); + var $57=$56; + var $58=HEAP32[(($57)>>2)]; + var $59=FUNCTION_TABLE[$54](((STRING_TABLE.__str60274)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$58,tempInt)); + __label__ = 12; break; + case 11: + var $61=$2; + var $62=$1; + var $63=(($62+56)|0); + var $64=$63; + var $65=HEAP32[(($64)>>2)]; + var $66=(($65)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=FUNCTION_TABLE[$61](((STRING_TABLE.__str61275)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$67,tempInt)); + __label__ = 12; break; + case 12: + __label__ = 14; break; + case 13: + var $71=$2; + var $72=$1; + var $73=(($72)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=FUNCTION_TABLE[$71](((STRING_TABLE.__str62276)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$74,tempInt)); + __label__ = 14; break; + case 14: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_value_dump["X"]=1; + +function _ir_function_dump($f, $ind, $oprintf) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $l; + var $v; + var $l1; + var $v2; + $1=$f; + $2=$ind; + $3=$oprintf; + var $4=$1; + var $5=(($4+32)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$3; + var $10=$2; + var $11=$1; + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$1; + var $15=(($14+32)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(((-$16))|0); + var $18=FUNCTION_TABLE[$9](((STRING_TABLE.__str32246)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10,HEAP32[(((tempInt)+(4))>>2)]=$13,HEAP32[(((tempInt)+(8))>>2)]=$17,tempInt)); + __label__ = 35; break; + case 4: + var $20=$3; + var $21=$2; + var $22=$1; + var $23=(($22)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=FUNCTION_TABLE[$20](((STRING_TABLE.__str33247)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$21,HEAP32[(((tempInt)+(4))>>2)]=$24,tempInt)); + var $26=$2; + var $27=_strncat($26, ((STRING_TABLE.__str34248)|0), 1024); + var $28=$1; + var $29=(($28+56)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 5; break; } else { __label__ = 10; break; } + case 5: + var $33=$3; + var $34=$2; + var $35=$1; + var $36=(($35+56)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=FUNCTION_TABLE[$33](((STRING_TABLE.__str35249)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$34,HEAP32[(((tempInt)+(4))>>2)]=$37,tempInt)); + $i=0; + __label__ = 6; break; + case 6: + var $40=$i; + var $41=$1; + var $42=(($41+56)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($40)>>>0) < (($43)>>>0); + if ($44) { __label__ = 7; break; } else { __label__ = 9; break; } + case 7: + var $46=$3; + var $47=$2; + var $48=FUNCTION_TABLE[$46](((STRING_TABLE.__str36250)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$47,tempInt)); + var $49=$i; + var $50=$1; + var $51=(($50+52)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($52+($49<<2))|0); + var $54=HEAP32[(($53)>>2)]; + var $55=$3; + _ir_value_dump($54, $55); + var $56=$3; + var $57=FUNCTION_TABLE[$56](((STRING_TABLE.__str30244)|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)); + __label__ = 8; break; + case 8: + var $59=$i; + var $60=((($59)+(1))|0); + $i=$60; + __label__ = 6; break; + case 9: + __label__ = 10; break; + case 10: + var $63=$3; + var $64=$2; + var $65=FUNCTION_TABLE[$63](((STRING_TABLE.__str37251)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$64,tempInt)); + $i=0; + __label__ = 11; break; + case 11: + var $67=$i; + var $68=$1; + var $69=(($68+56)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($67)>>>0) < (($70)>>>0); + if ($71) { __label__ = 12; break; } else { __label__ = 18; break; } + case 12: + var $73=$i; + var $74=$1; + var $75=(($74+52)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($76+($73<<2))|0); + var $78=HEAP32[(($77)>>2)]; + $v=$78; + var $79=$3; + var $80=$2; + var $81=$v; + var $82=(($81)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=FUNCTION_TABLE[$79](((STRING_TABLE.__str38252)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$80,HEAP32[(((tempInt)+(4))>>2)]=$83,tempInt)); + $l=0; + __label__ = 13; break; + case 13: + var $86=$l; + var $87=$v; + var $88=(($87+104)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($86)>>>0) < (($89)>>>0); + if ($90) { __label__ = 14; break; } else { __label__ = 16; break; } + case 14: + var $92=$3; + var $93=$l; + var $94=$v; + var $95=(($94+100)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=(($96+($93<<3))|0); + var $98=(($97)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=$l; + var $101=$v; + var $102=(($101+100)|0); + var $103=HEAP32[(($102)>>2)]; + var $104=(($103+($100<<3))|0); + var $105=(($104+4)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=FUNCTION_TABLE[$92](((STRING_TABLE.__str39253)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$99,HEAP32[(((tempInt)+(4))>>2)]=$106,tempInt)); + __label__ = 15; break; + case 15: + var $109=$l; + var $110=((($109)+(1))|0); + $l=$110; + __label__ = 13; break; + case 16: + var $112=$3; + var $113=FUNCTION_TABLE[$112](((STRING_TABLE.__str30244)|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)); + __label__ = 17; break; + case 17: + var $115=$i; + var $116=((($115)+(1))|0); + $i=$116; + __label__ = 11; break; + case 18: + $i=0; + __label__ = 19; break; + case 19: + var $119=$i; + var $120=$1; + var $121=(($120+44)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=(($119)>>>0) < (($122)>>>0); + if ($123) { __label__ = 20; break; } else { __label__ = 26; break; } + case 20: + var $125=$i; + var $126=$1; + var $127=(($126+40)|0); + var $128=HEAP32[(($127)>>2)]; + var $129=(($128+($125<<2))|0); + var $130=HEAP32[(($129)>>2)]; + $v2=$130; + var $131=$3; + var $132=$2; + var $133=$v2; + var $134=(($133)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=$v2; + var $137=(($136+68)|0); + var $138=(($137+8)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=FUNCTION_TABLE[$131](((STRING_TABLE.__str40254)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$132,HEAP32[(((tempInt)+(4))>>2)]=$135,HEAP32[(((tempInt)+(8))>>2)]=$139,tempInt)); + $l1=0; + __label__ = 21; break; + case 21: + var $142=$l1; + var $143=$v2; + var $144=(($143+104)|0); + var $145=HEAP32[(($144)>>2)]; + var $146=(($142)>>>0) < (($145)>>>0); + if ($146) { __label__ = 22; break; } else { __label__ = 24; break; } + case 22: + var $148=$3; + var $149=$l1; + var $150=$v2; + var $151=(($150+100)|0); + var $152=HEAP32[(($151)>>2)]; + var $153=(($152+($149<<3))|0); + var $154=(($153)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=$l1; + var $157=$v2; + var $158=(($157+100)|0); + var $159=HEAP32[(($158)>>2)]; + var $160=(($159+($156<<3))|0); + var $161=(($160+4)|0); + var $162=HEAP32[(($161)>>2)]; + var $163=FUNCTION_TABLE[$148](((STRING_TABLE.__str39253)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$155,HEAP32[(((tempInt)+(4))>>2)]=$162,tempInt)); + __label__ = 23; break; + case 23: + var $165=$l1; + var $166=((($165)+(1))|0); + $l1=$166; + __label__ = 21; break; + case 24: + var $168=$3; + var $169=FUNCTION_TABLE[$168](((STRING_TABLE.__str30244)|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)); + __label__ = 25; break; + case 25: + var $171=$i; + var $172=((($171)+(1))|0); + $i=$172; + __label__ = 19; break; + case 26: + var $174=$1; + var $175=(($174+24)|0); + var $176=HEAP32[(($175)>>2)]; + var $177=(($176)|0)!=0; + if ($177) { __label__ = 27; break; } else { __label__ = 34; break; } + case 27: + var $179=$3; + var $180=$2; + var $181=$1; + var $182=(($181+88)|0); + var $183=HEAP32[(($182)>>2)]; + var $184=FUNCTION_TABLE[$179](((STRING_TABLE.__str41255)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$180,HEAP32[(((tempInt)+(4))>>2)]=$183,tempInt)); + $i=0; + __label__ = 28; break; + case 28: + var $186=$i; + var $187=$1; + var $188=(($187+24)|0); + var $189=HEAP32[(($188)>>2)]; + var $190=(($186)>>>0) < (($189)>>>0); + if ($190) { __label__ = 29; break; } else { __label__ = 33; break; } + case 29: + var $192=$i; + var $193=$1; + var $194=(($193+20)|0); + var $195=HEAP32[(($194)>>2)]; + var $196=(($195+($192<<2))|0); + var $197=HEAP32[(($196)>>2)]; + var $198=(($197+72)|0); + var $199=HEAP32[(($198)>>2)]; + var $200=$1; + var $201=(($200+88)|0); + var $202=HEAP32[(($201)>>2)]; + var $203=(($199)|0)!=(($202)|0); + if ($203) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + var $205=$3; + var $206=$2; + var $207=$i; + var $208=$1; + var $209=(($208+20)|0); + var $210=HEAP32[(($209)>>2)]; + var $211=(($210+($207<<2))|0); + var $212=HEAP32[(($211)>>2)]; + var $213=(($212+72)|0); + var $214=HEAP32[(($213)>>2)]; + var $215=$1; + var $216=(($215+88)|0); + var $217=HEAP32[(($216)>>2)]; + var $218=FUNCTION_TABLE[$205](((STRING_TABLE.__str42256)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$206,HEAP32[(((tempInt)+(4))>>2)]=$214,HEAP32[(((tempInt)+(8))>>2)]=$217,tempInt)); + __label__ = 31; break; + case 31: + var $220=$i; + var $221=$1; + var $222=(($221+20)|0); + var $223=HEAP32[(($222)>>2)]; + var $224=(($223+($220<<2))|0); + var $225=HEAP32[(($224)>>2)]; + var $226=$2; + var $227=$3; + _ir_block_dump($225, $226, $227); + __label__ = 32; break; + case 32: + var $229=$i; + var $230=((($229)+(1))|0); + $i=$230; + __label__ = 28; break; + case 33: + __label__ = 34; break; + case 34: + var $233=$2; + var $234=_strlen($233); + var $235=((($234)-(1))|0); + var $236=$2; + var $237=(($236+$235)|0); + HEAP8[($237)]=0; + var $238=$3; + var $239=$2; + var $240=$1; + var $241=(($240)|0); + var $242=HEAP32[(($241)>>2)]; + var $243=FUNCTION_TABLE[$238](((STRING_TABLE.__str43257)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$239,HEAP32[(((tempInt)+(4))>>2)]=$242,tempInt)); + __label__ = 35; break; + case 35: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_function_dump["X"]=1; + +function _ir_block_dump($b, $ind, $oprintf) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $1=$b; + $2=$ind; + $3=$oprintf; + var $4=$3; + var $5=$2; + var $6=$1; + var $7=(($6)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=FUNCTION_TABLE[$4](((STRING_TABLE.__str44258)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5,HEAP32[(((tempInt)+(4))>>2)]=$8,tempInt)); + var $10=$2; + var $11=_strncat($10, ((STRING_TABLE.__str34248)|0), 1024); + $i=0; + __label__ = 3; break; + case 3: + var $13=$i; + var $14=$1; + var $15=(($14+20)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($13)>>>0) < (($16)>>>0); + if ($17) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $19=$i; + var $20=$1; + var $21=(($20+16)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22+($19<<2))|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$2; + var $26=$3; + _ir_instr_dump($24, $25, $26); + __label__ = 5; break; + case 5: + var $28=$i; + var $29=((($28)+(1))|0); + $i=$29; + __label__ = 3; break; + case 6: + var $31=$2; + var $32=_strlen($31); + var $33=((($32)-(1))|0); + var $34=$2; + var $35=(($34+$33)|0); + HEAP8[($35)]=0; + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_instr_dump($in, $ind, $oprintf) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $comma; + $1=$in; + $2=$ind; + $3=$oprintf; + $comma=0; + var $4=$3; + var $5=$2; + var $6=$1; + var $7=(($6+56)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=FUNCTION_TABLE[$4](((STRING_TABLE.__str47261)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$5,HEAP32[(((tempInt)+(4))>>2)]=$8,tempInt)); + var $10=$1; + var $11=(($10)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)==67; + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$1; + var $16=$2; + var $17=$3; + _dump_phi($15, $16, $17); + __label__ = 40; break; + case 4: + var $19=$2; + var $20=_strncat($19, ((STRING_TABLE.__str34248)|0), 1024); + var $21=$1; + var $22=(($21+12)|0); + var $23=(($22)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)!=0; + if ($25) { __label__ = 5; break; } else { __label__ = 11; break; } + case 5: + var $27=$1; + var $28=(($27+12)|0); + var $29=(($28+4)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $33=$1; + var $34=(($33+12)|0); + var $35=(($34+8)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36)|0)!=0; + if ($37) { __label__ = 7; break; } else { __label__ = 11; break; } + case 7: + var $39=$1; + var $40=(($39+12)|0); + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$3; + _ir_value_dump($42, $43); + var $44=$1; + var $45=(($44+12)|0); + var $46=(($45+4)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($47)|0)!=0; + if ($48) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + var $50=$1; + var $51=(($50+12)|0); + var $52=(($51+8)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=(($53)|0)!=0; + if ($54) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $56=$3; + var $57=FUNCTION_TABLE[$56](((STRING_TABLE.__str48262)|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)); + __label__ = 10; break; + case 10: + __label__ = 11; break; + case 11: + var $60=$1; + var $61=(($60)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)==51; + if ($63) { __label__ = 12; break; } else { __label__ = 13; break; } + case 12: + var $65=$3; + var $66=$1; + var $67=(($66+48)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=FUNCTION_TABLE[$65](((STRING_TABLE.__str49263)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$68,tempInt)); + __label__ = 14; break; + case 13: + var $71=$3; + var $72=$1; + var $73=(($72)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=_qc_opname($74); + var $76=FUNCTION_TABLE[$71](((STRING_TABLE.__str36250)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$75,tempInt)); + __label__ = 14; break; + case 14: + var $78=$1; + var $79=(($78+12)|0); + var $80=(($79)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81)|0)!=0; + if ($82) { __label__ = 15; break; } else { __label__ = 18; break; } + case 15: + var $84=$1; + var $85=(($84+12)|0); + var $86=(($85+4)|0); + var $87=HEAP32[(($86)>>2)]; + var $88=(($87)|0)!=0; + if ($88) { __label__ = 18; break; } else { __label__ = 16; break; } + case 16: + var $90=$1; + var $91=(($90+12)|0); + var $92=(($91+8)|0); + var $93=HEAP32[(($92)>>2)]; + var $94=(($93)|0)!=0; + if ($94) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $96=$1; + var $97=(($96+12)|0); + var $98=(($97)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=$3; + _ir_value_dump($99, $100); + $comma=((STRING_TABLE.__str50264)|0); + __label__ = 27; break; + case 18: + $i=1; + __label__ = 19; break; + case 19: + var $103=$i; + var $104=(($103)|0)!=3; + if ($104) { __label__ = 20; break; } else { __label__ = 26; break; } + case 20: + var $106=$i; + var $107=$1; + var $108=(($107+12)|0); + var $109=(($108+($106<<2))|0); + var $110=HEAP32[(($109)>>2)]; + var $111=(($110)|0)!=0; + if ($111) { __label__ = 21; break; } else { __label__ = 24; break; } + case 21: + var $113=$comma; + var $114=(($113)|0)!=0; + if ($114) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $116=$3; + var $117=$comma; + var $118=FUNCTION_TABLE[$116]($117, (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt)); + __label__ = 23; break; + case 23: + var $120=$i; + var $121=$1; + var $122=(($121+12)|0); + var $123=(($122+($120<<2))|0); + var $124=HEAP32[(($123)>>2)]; + var $125=$3; + _ir_value_dump($124, $125); + $comma=((STRING_TABLE.__str50264)|0); + __label__ = 24; break; + case 24: + __label__ = 25; break; + case 25: + var $128=$i; + var $129=((($128)+(1))|0); + $i=$129; + __label__ = 19; break; + case 26: + __label__ = 27; break; + case 27: + var $132=$1; + var $133=(($132+24)|0); + var $134=(($133)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=(($135)|0)!=0; + if ($136) { __label__ = 28; break; } else { __label__ = 31; break; } + case 28: + var $138=$comma; + var $139=(($138)|0)!=0; + if ($139) { __label__ = 29; break; } else { __label__ = 30; break; } + case 29: + var $141=$3; + var $142=$comma; + var $143=FUNCTION_TABLE[$141]($142, (tempInt=STACKTOP,STACKTOP += 1,STACKTOP = ((((STACKTOP)+3)>>2)<<2),assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=0,tempInt)); + __label__ = 30; break; + case 30: + var $145=$3; + var $146=$1; + var $147=(($146+24)|0); + var $148=(($147)|0); + var $149=HEAP32[(($148)>>2)]; + var $150=(($149)|0); + var $151=HEAP32[(($150)>>2)]; + var $152=FUNCTION_TABLE[$145](((STRING_TABLE.__str51265)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$151,tempInt)); + $comma=((STRING_TABLE.__str50264)|0); + __label__ = 31; break; + case 31: + var $154=$1; + var $155=(($154+24)|0); + var $156=(($155+4)|0); + var $157=HEAP32[(($156)>>2)]; + var $158=(($157)|0)!=0; + if ($158) { __label__ = 32; break; } else { __label__ = 33; break; } + case 32: + var $160=$3; + var $161=$comma; + var $162=$1; + var $163=(($162+24)|0); + var $164=(($163+4)|0); + var $165=HEAP32[(($164)>>2)]; + var $166=(($165)|0); + var $167=HEAP32[(($166)>>2)]; + var $168=FUNCTION_TABLE[$160](((STRING_TABLE.__str52266)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$161,HEAP32[(((tempInt)+(4))>>2)]=$167,tempInt)); + __label__ = 33; break; + case 33: + var $170=$1; + var $171=(($170+48)|0); + var $172=HEAP32[(($171)>>2)]; + var $173=(($172)|0)!=0; + if ($173) { __label__ = 34; break; } else { __label__ = 39; break; } + case 34: + var $175=$3; + var $176=FUNCTION_TABLE[$175](((STRING_TABLE.__str53267)|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)); + $i=0; + __label__ = 35; break; + case 35: + var $178=$i; + var $179=$1; + var $180=(($179+48)|0); + var $181=HEAP32[(($180)>>2)]; + var $182=(($178)|0)!=(($181)|0); + if ($182) { __label__ = 36; break; } else { __label__ = 38; break; } + case 36: + var $184=$3; + var $185=$i; + var $186=$1; + var $187=(($186+44)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=(($188+($185<<2))|0); + var $190=HEAP32[(($189)>>2)]; + var $191=(($190)|0); + var $192=HEAP32[(($191)>>2)]; + var $193=FUNCTION_TABLE[$184](((STRING_TABLE.__str54268)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$192,tempInt)); + __label__ = 37; break; + case 37: + var $195=$i; + var $196=((($195)+(1))|0); + $i=$196; + __label__ = 35; break; + case 38: + __label__ = 39; break; + case 39: + var $199=$3; + var $200=FUNCTION_TABLE[$199](((STRING_TABLE.__str30244)|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)); + var $201=$2; + var $202=_strlen($201); + var $203=((($202)-(1))|0); + var $204=$2; + var $205=(($204+$203)|0); + HEAP8[($205)]=0; + __label__ = 40; break; + case 40: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_instr_dump["X"]=1; + +function _dump_phi($in, $ind, $oprintf) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $1=$in; + $2=$ind; + $3=$oprintf; + var $4=$3; + var $5=$1; + var $6=(($5+12)|0); + var $7=(($6)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=FUNCTION_TABLE[$4](((STRING_TABLE.__str45259)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$10,tempInt)); + $i=0; + __label__ = 3; break; + case 3: + var $13=$i; + var $14=$1; + var $15=(($14+36)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($13)>>>0) < (($16)>>>0); + if ($17) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $19=$3; + var $20=$i; + var $21=$1; + var $22=(($21+32)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<3))|0); + var $25=(($24+4)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$i; + var $30=$1; + var $31=(($30+32)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=(($32+($29<<3))|0); + var $34=(($33)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=FUNCTION_TABLE[$19](((STRING_TABLE.__str46260)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$28,HEAP32[(((tempInt)+(4))>>2)]=$37,tempInt)); + __label__ = 5; break; + case 5: + var $40=$i; + var $41=((($40)+(1))|0); + $i=$41; + __label__ = 3; break; + case 6: + var $43=$3; + var $44=FUNCTION_TABLE[$43](((STRING_TABLE.__str30244)|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)); + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_dump_phi["X"]=1; + +function _gen_function_code($self) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $block; + var $stmt=__stackBase__; + $2=$self; + var $3=$2; + var $4=(($3+24)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $8=$2; + var $9=(($8+76)|0); + var $10=$2; + var $11=(($10)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($9)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($9+4)|0); + var $16=HEAP32[(($15)>>2)]; + _irerror($14, $16, ((STRING_TABLE.__str68282)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$12,tempInt)); + $1=0; + __label__ = 11; break; + case 4: + var $18=$2; + var $19=(($18+20)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20)|0); + var $22=HEAP32[(($21)>>2)]; + $block=$22; + var $23=$block; + var $24=(($23+80)|0); + var $25=HEAP8[($24)]; + var $26=(($25) & 1); + if ($26) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=1; + __label__ = 11; break; + case 6: + var $29=$2; + var $30=$block; + var $31=_gen_blocks_recursive($29, $30); + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $33=$2; + var $34=(($33+76)|0); + var $35=$2; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($34)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($34+4)|0); + var $41=HEAP32[(($40)>>2)]; + _irerror($39, $41, ((STRING_TABLE.__str69283)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$37,tempInt)); + $1=0; + __label__ = 11; break; + case 8: + var $43=(($stmt)|0); + HEAP16[(($43)>>1)]=66; + var $44=(($stmt+2)|0); + var $45=$44; + HEAP16[(($45)>>1)]=0; + var $46=(($stmt+4)|0); + var $47=$46; + HEAP16[(($47)>>1)]=0; + var $48=(($stmt+6)|0); + var $49=$48; + HEAP16[(($49)>>1)]=0; + var $50=_code_statements_add($stmt); + var $51=(($50)|0) < 0; + if ($51) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + $1=0; + __label__ = 11; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $55=$1; + STACKTOP = __stackBase__; + return $55; + default: assert(0, "bad label: " + __label__); + } +} +_gen_function_code["X"]=1; + +function _gen_blocks_recursive($func, $block) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $stmt=__stackBase__; + var $instr; + var $target; + var $ontrue; + var $onfalse; + var $stidx; + var $i; + var $p; + var $retvalue; + var $param; + $2=$func; + $3=$block; + __label__ = 3; break; + case 3: + var $5=$3; + var $6=(($5+80)|0); + HEAP8[($6)]=1; + var $7=HEAP32[((_code_statements_elements)>>2)]; + var $8=$3; + var $9=(($8+84)|0); + HEAP32[(($9)>>2)]=$7; + $i=0; + __label__ = 4; break; + case 4: + var $11=$i; + var $12=$3; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($11)>>>0) < (($14)>>>0); + if ($15) { __label__ = 5; break; } else { __label__ = 83; break; } + case 5: + var $17=$i; + var $18=$3; + var $19=(($18+16)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20+($17<<2))|0); + var $22=HEAP32[(($21)>>2)]; + $instr=$22; + var $23=$instr; + var $24=(($23)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)==67; + if ($26) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $28=$3; + var $29=(($28+4)|0); + var $30=(($29)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($29+4)|0); + var $33=HEAP32[(($32)>>2)]; + _irerror($31, $33, ((STRING_TABLE.__str70284)|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)); + $1=0; + __label__ = 84; break; + case 7: + var $35=$instr; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)|0)==68; + if ($38) { __label__ = 8; break; } else { __label__ = 13; break; } + case 8: + var $40=$instr; + var $41=(($40+24)|0); + var $42=(($41)|0); + var $43=HEAP32[(($42)>>2)]; + $target=$43; + var $44=$target; + var $45=(($44+80)|0); + var $46=HEAP8[($45)]; + var $47=(($46) & 1); + if ($47) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $49=$target; + $3=$49; + __label__ = 3; break; + case 10: + var $51=(($stmt)|0); + HEAP16[(($51)>>1)]=61; + var $52=$target; + var $53=(($52+84)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=HEAP32[((_code_statements_elements)>>2)]; + var $56=((($54)-($55))|0); + var $57=(($56) & 65535); + var $58=(($stmt+2)|0); + var $59=$58; + HEAP16[(($59)>>1)]=$57; + var $60=(($stmt+4)|0); + var $61=$60; + HEAP16[(($61)>>1)]=0; + var $62=(($stmt+6)|0); + var $63=$62; + HEAP16[(($63)>>1)]=0; + var $64=_code_statements_add($stmt); + var $65=(($64)|0) < 0; + if ($65) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + $1=0; + __label__ = 84; break; + case 12: + $1=1; + __label__ = 84; break; + case 13: + var $69=$instr; + var $70=(($69)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=(($71)|0)==69; + if ($72) { __label__ = 14; break; } else { __label__ = 37; break; } + case 14: + var $74=$instr; + var $75=(($74+24)|0); + var $76=(($75)|0); + var $77=HEAP32[(($76)>>2)]; + $ontrue=$77; + var $78=$instr; + var $79=(($78+24)|0); + var $80=(($79+4)|0); + var $81=HEAP32[(($80)>>2)]; + $onfalse=$81; + var $82=$instr; + var $83=(($82+12)|0); + var $84=(($83)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=_ir_value_code_addr($85); + var $87=(($86) & 65535); + var $88=(($stmt+2)|0); + var $89=$88; + HEAP16[(($89)>>1)]=$87; + var $90=(($stmt+4)|0); + var $91=$90; + HEAP16[(($91)>>1)]=0; + var $92=(($stmt+6)|0); + var $93=$92; + HEAP16[(($93)>>1)]=0; + var $94=$ontrue; + var $95=(($94+80)|0); + var $96=HEAP8[($95)]; + var $97=(($96) & 1); + if ($97) { __label__ = 15; break; } else { __label__ = 18; break; } + case 15: + var $99=(($stmt)|0); + HEAP16[(($99)>>1)]=49; + var $100=$ontrue; + var $101=(($100+84)|0); + var $102=HEAP32[(($101)>>2)]; + var $103=HEAP32[((_code_statements_elements)>>2)]; + var $104=((($102)-($103))|0); + var $105=(($104) & 65535); + var $106=(($stmt+4)|0); + var $107=$106; + HEAP16[(($107)>>1)]=$105; + var $108=_code_statements_add($stmt); + var $109=(($108)|0) < 0; + if ($109) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + $1=0; + __label__ = 84; break; + case 17: + __label__ = 18; break; + case 18: + var $113=$onfalse; + var $114=(($113+80)|0); + var $115=HEAP8[($114)]; + var $116=(($115) & 1); + if ($116) { __label__ = 19; break; } else { __label__ = 22; break; } + case 19: + var $118=(($stmt)|0); + HEAP16[(($118)>>1)]=50; + var $119=$onfalse; + var $120=(($119+84)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=HEAP32[((_code_statements_elements)>>2)]; + var $123=((($121)-($122))|0); + var $124=(($123) & 65535); + var $125=(($stmt+4)|0); + var $126=$125; + HEAP16[(($126)>>1)]=$124; + var $127=_code_statements_add($stmt); + var $128=(($127)|0) < 0; + if ($128) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + $1=0; + __label__ = 84; break; + case 21: + __label__ = 22; break; + case 22: + var $132=$ontrue; + var $133=(($132+80)|0); + var $134=HEAP8[($133)]; + var $135=(($134) & 1); + if ($135) { __label__ = 26; break; } else { __label__ = 23; break; } + case 23: + var $137=$onfalse; + var $138=(($137+80)|0); + var $139=HEAP8[($138)]; + var $140=(($139) & 1); + if ($140) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + var $142=$ontrue; + $3=$142; + __label__ = 3; break; + case 25: + __label__ = 26; break; + case 26: + var $145=$onfalse; + var $146=(($145+80)|0); + var $147=HEAP8[($146)]; + var $148=(($147) & 1); + if ($148) { __label__ = 30; break; } else { __label__ = 27; break; } + case 27: + var $150=$ontrue; + var $151=(($150+80)|0); + var $152=HEAP8[($151)]; + var $153=(($152) & 1); + if ($153) { __label__ = 28; break; } else { __label__ = 29; break; } + case 28: + var $155=$onfalse; + $3=$155; + __label__ = 3; break; + case 29: + __label__ = 30; break; + case 30: + var $158=(($stmt)|0); + HEAP16[(($158)>>1)]=50; + var $159=HEAP32[((_code_statements_elements)>>2)]; + $stidx=$159; + var $160=_code_statements_add($stmt); + var $161=(($160)|0) < 0; + if ($161) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + $1=0; + __label__ = 84; break; + case 32: + var $164=$2; + var $165=$ontrue; + var $166=_gen_blocks_recursive($164, $165); + if ($166) { __label__ = 34; break; } else { __label__ = 33; break; } + case 33: + $1=0; + __label__ = 84; break; + case 34: + var $169=HEAP32[((_code_statements_elements)>>2)]; + var $170=$stidx; + var $171=((($169)-($170))|0); + var $172=(($171) & 65535); + var $173=$stidx; + var $174=HEAP32[((_code_statements_data)>>2)]; + var $175=(($174+($173<<3))|0); + var $176=(($175+4)|0); + var $177=$176; + HEAP16[(($177)>>1)]=$172; + var $178=$onfalse; + var $179=(($178+80)|0); + var $180=HEAP8[($179)]; + var $181=(($180) & 1); + if ($181) { __label__ = 35; break; } else { __label__ = 36; break; } + case 35: + var $183=$onfalse; + var $184=(($183+84)|0); + var $185=HEAP32[(($184)>>2)]; + var $186=$stidx; + var $187=((($185)-($186))|0); + var $188=(($187) & 65535); + var $189=$stidx; + var $190=HEAP32[((_code_statements_data)>>2)]; + var $191=(($190+($189<<3))|0); + var $192=(($191+4)|0); + var $193=$192; + HEAP16[(($193)>>1)]=$188; + var $194=(($stmt)|0); + HEAP16[(($194)>>1)]=61; + var $195=$onfalse; + var $196=(($195+84)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=HEAP32[((_code_statements_elements)>>2)]; + var $199=((($197)-($198))|0); + var $200=(($199) & 65535); + var $201=(($stmt+2)|0); + var $202=$201; + HEAP16[(($202)>>1)]=$200; + var $203=(($stmt+4)|0); + var $204=$203; + HEAP16[(($204)>>1)]=0; + var $205=(($stmt+6)|0); + var $206=$205; + HEAP16[(($206)>>1)]=0; + var $207=_code_statements_add($stmt); + var $208=(($207)|0) >= 0; + $1=$208; + __label__ = 84; break; + case 36: + var $210=$onfalse; + $3=$210; + __label__ = 3; break; + case 37: + var $212=$instr; + var $213=(($212)|0); + var $214=HEAP32[(($213)>>2)]; + var $215=(($214)|0) >= 51; + if ($215) { __label__ = 38; break; } else { __label__ = 62; break; } + case 38: + var $217=$instr; + var $218=(($217)|0); + var $219=HEAP32[(($218)>>2)]; + var $220=(($219)|0) <= 59; + if ($220) { __label__ = 39; break; } else { __label__ = 62; break; } + case 39: + $p=0; + __label__ = 40; break; + case 40: + var $223=$p; + var $224=$instr; + var $225=(($224+48)|0); + var $226=HEAP32[(($225)>>2)]; + var $227=(($223)>>>0) < (($226)>>>0); + if ($227) { __label__ = 41; break; } else { __label__ = 48; break; } + case 41: + var $229=$p; + var $230=$instr; + var $231=(($230+44)|0); + var $232=HEAP32[(($231)>>2)]; + var $233=(($232+($229<<2))|0); + var $234=HEAP32[(($233)>>2)]; + $param=$234; + var $235=(($stmt)|0); + HEAP16[(($235)>>1)]=31; + var $236=(($stmt+6)|0); + var $237=$236; + HEAP16[(($237)>>1)]=0; + var $238=$param; + var $239=(($238+4)|0); + var $240=HEAP32[(($239)>>2)]; + var $241=(($240)|0)==5; + if ($241) { __label__ = 42; break; } else { __label__ = 43; break; } + case 42: + var $243=$param; + var $244=(($243+20)|0); + var $245=HEAP32[(($244)>>2)]; + var $246=((_field_store_instr+($245<<1))|0); + var $247=HEAP16[(($246)>>1)]; + var $248=(($stmt)|0); + HEAP16[(($248)>>1)]=$247; + __label__ = 44; break; + case 43: + var $250=$param; + var $251=(($250+4)|0); + var $252=HEAP32[(($251)>>2)]; + var $253=((_type_store_instr+($252<<1))|0); + var $254=HEAP16[(($253)>>1)]; + var $255=(($stmt)|0); + HEAP16[(($255)>>1)]=$254; + __label__ = 44; break; + case 44: + var $257=$param; + var $258=_ir_value_code_addr($257); + var $259=(($258) & 65535); + var $260=(($stmt+2)|0); + var $261=$260; + HEAP16[(($261)>>1)]=$259; + var $262=$p; + var $263=((($262)*(3))|0); + var $264=((($263)+(4))|0); + var $265=(($264) & 65535); + var $266=(($stmt+4)|0); + var $267=$266; + HEAP16[(($267)>>1)]=$265; + var $268=_code_statements_add($stmt); + var $269=(($268)|0) < 0; + if ($269) { __label__ = 45; break; } else { __label__ = 46; break; } + case 45: + $1=0; + __label__ = 84; break; + case 46: + __label__ = 47; break; + case 47: + var $273=$p; + var $274=((($273)+(1))|0); + $p=$274; + __label__ = 40; break; + case 48: + var $276=$instr; + var $277=(($276+48)|0); + var $278=HEAP32[(($277)>>2)]; + var $279=((($278)+(51))|0); + var $280=(($279) & 65535); + var $281=(($stmt)|0); + HEAP16[(($281)>>1)]=$280; + var $282=(($stmt)|0); + var $283=HEAP16[(($282)>>1)]; + var $284=(($283)&65535); + var $285=(($284)|0) > 59; + if ($285) { __label__ = 49; break; } else { __label__ = 50; break; } + case 49: + var $287=(($stmt)|0); + HEAP16[(($287)>>1)]=59; + __label__ = 50; break; + case 50: + var $289=$instr; + var $290=(($289+12)|0); + var $291=(($290+4)|0); + var $292=HEAP32[(($291)>>2)]; + var $293=_ir_value_code_addr($292); + var $294=(($293) & 65535); + var $295=(($stmt+2)|0); + var $296=$295; + HEAP16[(($296)>>1)]=$294; + var $297=(($stmt+4)|0); + var $298=$297; + HEAP16[(($298)>>1)]=0; + var $299=(($stmt+6)|0); + var $300=$299; + HEAP16[(($300)>>1)]=0; + var $301=_code_statements_add($stmt); + var $302=(($301)|0) < 0; + if ($302) { __label__ = 51; break; } else { __label__ = 52; break; } + case 51: + $1=0; + __label__ = 84; break; + case 52: + var $305=$instr; + var $306=(($305+12)|0); + var $307=(($306)|0); + var $308=HEAP32[(($307)>>2)]; + $retvalue=$308; + var $309=$retvalue; + var $310=(($309)|0)!=0; + if ($310) { __label__ = 53; break; } else { __label__ = 61; break; } + case 53: + var $312=$retvalue; + var $313=(($312+8)|0); + var $314=HEAP32[(($313)>>2)]; + var $315=(($314)|0)!=4; + if ($315) { __label__ = 54; break; } else { __label__ = 61; break; } + case 54: + var $317=$retvalue; + var $318=(($317+104)|0); + var $319=HEAP32[(($318)>>2)]; + var $320=(($319)|0)!=0; + if ($320) { __label__ = 55; break; } else { __label__ = 61; break; } + case 55: + var $322=$retvalue; + var $323=(($322+4)|0); + var $324=HEAP32[(($323)>>2)]; + var $325=(($324)|0)==5; + if ($325) { __label__ = 56; break; } else { __label__ = 57; break; } + case 56: + var $327=$retvalue; + var $328=(($327+4)|0); + var $329=HEAP32[(($328)>>2)]; + var $330=((_field_store_instr+($329<<1))|0); + var $331=HEAP16[(($330)>>1)]; + var $332=(($stmt)|0); + HEAP16[(($332)>>1)]=$331; + __label__ = 58; break; + case 57: + var $334=$retvalue; + var $335=(($334+4)|0); + var $336=HEAP32[(($335)>>2)]; + var $337=((_type_store_instr+($336<<1))|0); + var $338=HEAP16[(($337)>>1)]; + var $339=(($stmt)|0); + HEAP16[(($339)>>1)]=$338; + __label__ = 58; break; + case 58: + var $341=(($stmt+2)|0); + var $342=$341; + HEAP16[(($342)>>1)]=1; + var $343=$retvalue; + var $344=_ir_value_code_addr($343); + var $345=(($344) & 65535); + var $346=(($stmt+4)|0); + var $347=$346; + HEAP16[(($347)>>1)]=$345; + var $348=(($stmt+6)|0); + var $349=$348; + HEAP16[(($349)>>1)]=0; + var $350=_code_statements_add($stmt); + var $351=(($350)|0) < 0; + if ($351) { __label__ = 59; break; } else { __label__ = 60; break; } + case 59: + $1=0; + __label__ = 84; break; + case 60: + __label__ = 61; break; + case 61: + __label__ = 82; break; + case 62: + var $356=$instr; + var $357=(($356)|0); + var $358=HEAP32[(($357)>>2)]; + var $359=(($358)|0)==60; + if ($359) { __label__ = 63; break; } else { __label__ = 64; break; } + case 63: + var $361=$3; + var $362=(($361+4)|0); + var $363=(($362)|0); + var $364=HEAP32[(($363)>>2)]; + var $365=(($362+4)|0); + var $366=HEAP32[(($365)>>2)]; + _irerror($364, $366, ((STRING_TABLE.__str71285)|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)); + $1=0; + __label__ = 84; break; + case 64: + var $368=$instr; + var $369=(($368)|0); + var $370=HEAP32[(($369)>>2)]; + var $371=(($370) & 65535); + var $372=(($stmt)|0); + HEAP16[(($372)>>1)]=$371; + var $373=(($stmt+2)|0); + var $374=$373; + HEAP16[(($374)>>1)]=0; + var $375=(($stmt+4)|0); + var $376=$375; + HEAP16[(($376)>>1)]=0; + var $377=(($stmt+6)|0); + var $378=$377; + HEAP16[(($378)>>1)]=0; + var $379=$instr; + var $380=(($379+12)|0); + var $381=(($380)|0); + var $382=HEAP32[(($381)>>2)]; + var $383=(($382)|0)!=0; + if ($383) { __label__ = 65; break; } else { __label__ = 66; break; } + case 65: + var $385=$instr; + var $386=(($385+12)|0); + var $387=(($386)|0); + var $388=HEAP32[(($387)>>2)]; + var $389=_ir_value_code_addr($388); + var $390=(($389) & 65535); + var $391=(($stmt+6)|0); + var $392=$391; + HEAP16[(($392)>>1)]=$390; + __label__ = 66; break; + case 66: + var $394=$instr; + var $395=(($394+12)|0); + var $396=(($395+4)|0); + var $397=HEAP32[(($396)>>2)]; + var $398=(($397)|0)!=0; + if ($398) { __label__ = 67; break; } else { __label__ = 68; break; } + case 67: + var $400=$instr; + var $401=(($400+12)|0); + var $402=(($401+4)|0); + var $403=HEAP32[(($402)>>2)]; + var $404=_ir_value_code_addr($403); + var $405=(($404) & 65535); + var $406=(($stmt+2)|0); + var $407=$406; + HEAP16[(($407)>>1)]=$405; + __label__ = 68; break; + case 68: + var $409=$instr; + var $410=(($409+12)|0); + var $411=(($410+8)|0); + var $412=HEAP32[(($411)>>2)]; + var $413=(($412)|0)!=0; + if ($413) { __label__ = 69; break; } else { __label__ = 70; break; } + case 69: + var $415=$instr; + var $416=(($415+12)|0); + var $417=(($416+8)|0); + var $418=HEAP32[(($417)>>2)]; + var $419=_ir_value_code_addr($418); + var $420=(($419) & 65535); + var $421=(($stmt+4)|0); + var $422=$421; + HEAP16[(($422)>>1)]=$420; + __label__ = 70; break; + case 70: + var $424=(($stmt)|0); + var $425=HEAP16[(($424)>>1)]; + var $426=(($425)&65535); + var $427=(($426)|0)==43; + if ($427) { __label__ = 72; break; } else { __label__ = 71; break; } + case 71: + var $429=(($stmt)|0); + var $430=HEAP16[(($429)>>1)]; + var $431=(($430)&65535); + var $432=(($431)|0)==0; + if ($432) { __label__ = 72; break; } else { __label__ = 73; break; } + case 72: + var $434=(($stmt+6)|0); + var $435=$434; + var $436=HEAP16[(($435)>>1)]; + var $437=(($stmt+2)|0); + var $438=$437; + HEAP16[(($438)>>1)]=$436; + var $439=(($stmt+6)|0); + var $440=$439; + HEAP16[(($440)>>1)]=0; + __label__ = 79; break; + case 73: + var $442=(($stmt)|0); + var $443=HEAP16[(($442)>>1)]; + var $444=(($443)&65535); + var $445=(($444)|0) >= 31; + if ($445) { __label__ = 74; break; } else { __label__ = 75; break; } + case 74: + var $447=(($stmt)|0); + var $448=HEAP16[(($447)>>1)]; + var $449=(($448)&65535); + var $450=(($449)|0) <= 36; + if ($450) { __label__ = 77; break; } else { __label__ = 75; break; } + case 75: + var $452=(($stmt)|0); + var $453=HEAP16[(($452)>>1)]; + var $454=(($453)&65535); + var $455=(($454)|0) >= 37; + if ($455) { __label__ = 76; break; } else { __label__ = 78; break; } + case 76: + var $457=(($stmt)|0); + var $458=HEAP16[(($457)>>1)]; + var $459=(($458)&65535); + var $460=(($459)|0) <= 42; + if ($460) { __label__ = 77; break; } else { __label__ = 78; break; } + case 77: + var $462=(($stmt+6)|0); + var $463=$462; + var $464=HEAP16[(($463)>>1)]; + var $465=(($stmt+4)|0); + var $466=$465; + HEAP16[(($466)>>1)]=$464; + var $467=(($stmt+6)|0); + var $468=$467; + HEAP16[(($468)>>1)]=0; + __label__ = 78; break; + case 78: + __label__ = 79; break; + case 79: + var $471=_code_statements_add($stmt); + var $472=(($471)|0) < 0; + if ($472) { __label__ = 80; break; } else { __label__ = 81; break; } + case 80: + $1=0; + __label__ = 84; break; + case 81: + __label__ = 82; break; + case 82: + var $476=$i; + var $477=((($476)+(1))|0); + $i=$477; + __label__ = 4; break; + case 83: + $1=1; + __label__ = 84; break; + case 84: + var $480=$1; + STACKTOP = __stackBase__; + return $480; + default: assert(0, "bad label: " + __label__); + } +} +_gen_blocks_recursive["X"]=1; + +function _gen_global_pointer($global) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $target; + $2=$global; + var $3=$2; + var $4=(($3+52)|0); + var $5=HEAP8[($4)]; + var $6=(($5) & 1); + if ($6) { __label__ = 3; break; } else { __label__ = 8; break; } + case 3: + var $8=$2; + var $9=(($8+56)|0); + var $10=$9; + var $11=HEAP32[(($10)>>2)]; + $target=$11; + var $12=$target; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $15=$2; + var $16=(($15+12)|0); + var $17=$2; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($16+4)|0); + var $23=HEAP32[(($22)>>2)]; + _irerror($21, $23, ((STRING_TABLE.__str83297)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$19,tempInt)); + $1=0; + __label__ = 12; break; + case 5: + var $25=$target; + var $26=(($25+68)|0); + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $31=$2; + var $32=(($31+12)|0); + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($32+4)|0); + var $36=HEAP32[(($35)>>2)]; + _irerror($34, $36, ((STRING_TABLE.__str82296)|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)); + $1=0; + __label__ = 12; break; + case 7: + var $38=$2; + var $39=$target; + var $40=(($39+68)|0); + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=_code_globals_add($42); + _ir_value_code_setaddr($38, $43); + __label__ = 9; break; + case 8: + var $45=$2; + var $46=_code_globals_add(0); + _ir_value_code_setaddr($45, $46); + __label__ = 9; break; + case 9: + var $48=$2; + var $49=(($48+68)|0); + var $50=(($49)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=(($51)|0) < 0; + if ($52) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + $1=0; + __label__ = 12; break; + case 11: + $1=1; + __label__ = 12; break; + case 12: + var $56=$1; + STACKTOP = __stackBase__; + return $56; + default: assert(0, "bad label: " + __label__); + } +} +_gen_global_pointer["X"]=1; + +function _gen_global_field($global) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $fld; + $2=$global; + var $3=$2; + var $4=(($3+52)|0); + var $5=HEAP8[($4)]; + var $6=(($5) & 1); + if ($6) { __label__ = 3; break; } else { __label__ = 10; break; } + case 3: + var $8=$2; + var $9=(($8+56)|0); + var $10=$9; + var $11=HEAP32[(($10)>>2)]; + $fld=$11; + var $12=$fld; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $15=$2; + var $16=(($15+12)|0); + var $17=$2; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($16+4)|0); + var $23=HEAP32[(($22)>>2)]; + _irerror($21, $23, ((STRING_TABLE.__str81295)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$19,tempInt)); + $1=0; + __label__ = 16; break; + case 5: + var $25=$fld; + var $26=(($25+68)|0); + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)!=0; + if ($29) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $31=$2; + var $32=(($31+12)|0); + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($32+4)|0); + var $36=HEAP32[(($35)>>2)]; + _irerror($34, $36, ((STRING_TABLE.__str82296)|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)); + $1=0; + __label__ = 16; break; + case 7: + var $38=$2; + var $39=$fld; + var $40=(($39+68)|0); + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=HEAP32[((_code_globals_data)>>2)]; + var $44=(($43+($42<<2))|0); + var $45=HEAP32[(($44)>>2)]; + var $46=_code_globals_add($45); + _ir_value_code_setaddr($38, $46); + var $47=$2; + var $48=(($47+20)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($49)|0)==3; + if ($50) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $52=$fld; + var $53=(($52+68)|0); + var $54=(($53)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=HEAP32[((_code_globals_data)>>2)]; + var $57=(($56+($55<<2))|0); + var $58=HEAP32[(($57)>>2)]; + var $59=((($58)+(1))|0); + var $60=_code_globals_add($59); + var $61=$fld; + var $62=(($61+68)|0); + var $63=(($62)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=HEAP32[((_code_globals_data)>>2)]; + var $66=(($65+($64<<2))|0); + var $67=HEAP32[(($66)>>2)]; + var $68=((($67)+(2))|0); + var $69=_code_globals_add($68); + __label__ = 9; break; + case 9: + __label__ = 13; break; + case 10: + var $72=$2; + var $73=_code_globals_add(0); + _ir_value_code_setaddr($72, $73); + var $74=$2; + var $75=(($74+20)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($76)|0)==3; + if ($77) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $79=_code_globals_add(0); + var $80=_code_globals_add(0); + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + var $83=$2; + var $84=(($83+68)|0); + var $85=(($84)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=(($86)|0) < 0; + if ($87) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + $1=0; + __label__ = 16; break; + case 15: + $1=1; + __label__ = 16; break; + case 16: + var $91=$1; + STACKTOP = __stackBase__; + return $91; + default: assert(0, "bad label: " + __label__); + } +} +_gen_global_field["X"]=1; + +function _ir_op_read_write($op, $read, $write) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $1=$op; + $2=$read; + $3=$write; + var $4=$1; + if ((($4)|0) == 68 || (($4)|0) == 61) { + __label__ = 3; break; + } + else if ((($4)|0) == 49 || (($4)|0) == 50 || (($4)|0) == 43 || (($4)|0) == 69) { + __label__ = 4; break; + } + else if ((($4)|0) == 37 || (($4)|0) == 38 || (($4)|0) == 39 || (($4)|0) == 40 || (($4)|0) == 41 || (($4)|0) == 42) { + __label__ = 5; break; + } + else { + __label__ = 6; break; + } + + case 3: + var $6=$3; + HEAP32[(($6)>>2)]=0; + var $7=$2; + HEAP32[(($7)>>2)]=0; + __label__ = 7; break; + case 4: + var $9=$3; + HEAP32[(($9)>>2)]=0; + var $10=$2; + HEAP32[(($10)>>2)]=1; + __label__ = 7; break; + case 5: + var $12=$3; + HEAP32[(($12)>>2)]=0; + var $13=$2; + HEAP32[(($13)>>2)]=7; + __label__ = 7; break; + case 6: + var $15=$3; + HEAP32[(($15)>>2)]=1; + var $16=$2; + HEAP32[(($16)>>2)]=6; + __label__ = 7; break; + case 7: + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _gen_global_function($ir, $global) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $fun=__stackBase__; + var $irfun; + var $i; + var $local_var_end; + var $last; + var $v; + $2=$ir; + $3=$global; + var $4=$3; + var $5=(($4+52)|0); + var $6=HEAP8[($5)]; + var $7=(($6) & 1); + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$3; + var $10=(($9+56)|0); + var $11=$10; + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $15=$3; + var $16=(($15+12)|0); + var $17=$3; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($16+4)|0); + var $23=HEAP32[(($22)>>2)]; + _irerror($21, $23, ((STRING_TABLE.__str79293)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$19,tempInt)); + $1=0; + __label__ = 32; break; + case 5: + var $25=$3; + var $26=(($25+56)|0); + var $27=$26; + var $28=HEAP32[(($27)>>2)]; + $irfun=$28; + var $29=$3; + var $30=(($29+68)|0); + var $31=(($30+4)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=(($fun+16)|0); + HEAP32[(($33)>>2)]=$32; + var $34=$2; + var $35=$3; + var $36=(($35+12)|0); + var $37=(($36)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=_ir_builder_filestring($34, $38); + var $40=(($fun+20)|0); + HEAP32[(($40)>>2)]=$39; + var $41=(($fun+12)|0); + HEAP32[(($41)>>2)]=0; + var $42=$irfun; + var $43=(($42+12)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($fun+24)|0); + HEAP32[(($45)>>2)]=$44; + $i=0; + __label__ = 6; break; + case 6: + var $47=$i; + var $48=(($47)>>>0) < 8; + if ($48) { __label__ = 7; break; } else { __label__ = 12; break; } + case 7: + var $50=$i; + var $51=(($fun+24)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($50)>>>0) >= (($52)>>>0); + if ($53) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $55=$i; + var $56=(($fun+28)|0); + var $57=(($56+$55)|0); + HEAP8[($57)]=0; + __label__ = 10; break; + case 9: + var $59=$i; + var $60=$irfun; + var $61=(($60+8)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62+($59<<2))|0); + var $64=HEAP32[(($63)>>2)]; + var $65=((_type_sizeof+($64<<2))|0); + var $66=HEAP32[(($65)>>2)]; + var $67=(($66) & 255); + var $68=$i; + var $69=(($fun+28)|0); + var $70=(($69+$68)|0); + HEAP8[($70)]=$67; + __label__ = 10; break; + case 10: + __label__ = 11; break; + case 11: + var $73=$i; + var $74=((($73)+(1))|0); + $i=$74; + __label__ = 6; break; + case 12: + var $76=HEAP32[((_code_globals_elements)>>2)]; + var $77=(($fun+4)|0); + HEAP32[(($77)>>2)]=$76; + var $78=(($fun+4)|0); + var $79=HEAP32[(($78)>>2)]; + $local_var_end=$79; + $i=0; + __label__ = 13; break; + case 13: + var $81=$i; + var $82=$irfun; + var $83=(($82+56)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=(($81)>>>0) < (($84)>>>0); + if ($85) { __label__ = 14; break; } else { __label__ = 18; break; } + case 14: + var $87=$2; + var $88=$i; + var $89=$irfun; + var $90=(($89+52)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=(($91+($88<<2))|0); + var $93=HEAP32[(($92)>>2)]; + var $94=_ir_builder_gen_global($87, $93, 1); + if ($94) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $96=$i; + var $97=$irfun; + var $98=(($97+52)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=(($99+($96<<2))|0); + var $101=HEAP32[(($100)>>2)]; + var $102=(($101+12)|0); + var $103=$i; + var $104=$irfun; + var $105=(($104+52)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=(($106+($103<<2))|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108)|0); + var $110=HEAP32[(($109)>>2)]; + var $111=(($102)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($102+4)|0); + var $114=HEAP32[(($113)>>2)]; + _irerror($112, $114, ((STRING_TABLE.__str80294)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$110,tempInt)); + $1=0; + __label__ = 32; break; + case 16: + __label__ = 17; break; + case 17: + var $117=$i; + var $118=((($117)+(1))|0); + $i=$118; + __label__ = 13; break; + case 18: + var $120=$irfun; + var $121=(($120+56)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=(($122)|0)!=0; + if ($123) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $125=$irfun; + var $126=(($125+56)|0); + var $127=HEAP32[(($126)>>2)]; + var $128=((($127)-(1))|0); + var $129=$irfun; + var $130=(($129+52)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=(($131+($128<<2))|0); + var $133=HEAP32[(($132)>>2)]; + $last=$133; + var $134=$last; + var $135=(($134+68)|0); + var $136=(($135)|0); + var $137=HEAP32[(($136)>>2)]; + $local_var_end=$137; + var $138=$last; + var $139=(($138+4)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=((_type_sizeof+($140<<2))|0); + var $142=HEAP32[(($141)>>2)]; + var $143=$local_var_end; + var $144=((($143)+($142))|0); + $local_var_end=$144; + __label__ = 20; break; + case 20: + $i=0; + __label__ = 21; break; + case 21: + var $147=$i; + var $148=$irfun; + var $149=(($148+44)|0); + var $150=HEAP32[(($149)>>2)]; + var $151=(($147)>>>0) < (($150)>>>0); + if ($151) { __label__ = 22; break; } else { __label__ = 24; break; } + case 22: + var $153=$i; + var $154=$irfun; + var $155=(($154+40)|0); + var $156=HEAP32[(($155)>>2)]; + var $157=(($156+($153<<2))|0); + var $158=HEAP32[(($157)>>2)]; + $v=$158; + var $159=$v; + var $160=$local_var_end; + var $161=$v; + var $162=(($161+68)|0); + var $163=(($162+8)|0); + var $164=HEAP32[(($163)>>2)]; + var $165=((($160)+($164))|0); + _ir_value_code_setaddr($159, $165); + __label__ = 23; break; + case 23: + var $167=$i; + var $168=((($167)+(1))|0); + $i=$168; + __label__ = 21; break; + case 24: + $i=0; + __label__ = 25; break; + case 25: + var $171=$i; + var $172=$irfun; + var $173=(($172+64)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=(($171)>>>0) < (($174)>>>0); + if ($175) { __label__ = 26; break; } else { __label__ = 28; break; } + case 26: + var $177=_code_globals_add(0); + __label__ = 27; break; + case 27: + var $179=$i; + var $180=((($179)+(1))|0); + $i=$180; + __label__ = 25; break; + case 28: + var $182=HEAP32[((_code_globals_elements)>>2)]; + var $183=(($fun+4)|0); + var $184=HEAP32[(($183)>>2)]; + var $185=((($182)-($184))|0); + var $186=(($fun+8)|0); + HEAP32[(($186)>>2)]=$185; + var $187=$irfun; + var $188=(($187+32)|0); + var $189=HEAP32[(($188)>>2)]; + var $190=(($189)|0)!=0; + if ($190) { __label__ = 29; break; } else { __label__ = 30; break; } + case 29: + var $192=$irfun; + var $193=(($192+32)|0); + var $194=HEAP32[(($193)>>2)]; + var $195=(($fun)|0); + HEAP32[(($195)>>2)]=$194; + __label__ = 31; break; + case 30: + var $197=HEAP32[((_code_functions_elements)>>2)]; + var $198=$irfun; + var $199=(($198+84)|0); + HEAP32[(($199)>>2)]=$197; + var $200=HEAP32[((_code_statements_elements)>>2)]; + var $201=(($fun)|0); + HEAP32[(($201)>>2)]=$200; + __label__ = 31; break; + case 31: + var $203=_code_functions_add($fun); + var $204=(($203)|0) >= 0; + $1=$204; + __label__ = 32; break; + case 32: + var $206=$1; + STACKTOP = __stackBase__; + return $206; + default: assert(0, "bad label: " + __label__); + } +} +_gen_global_function["X"]=1; + +function _ir_builder_filestring($ir, $filename) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $str; + $2=$ir; + $3=$filename; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+44)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+40)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<2))|0); + var $16=HEAP32[(($15)>>2)]; + var $17=$3; + var $18=(($16)|0)==(($17)|0); + if ($18) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $20=$i; + var $21=$2; + var $22=(($21+52)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<2))|0); + var $25=HEAP32[(($24)>>2)]; + $1=$25; + __label__ = 13; break; + case 6: + __label__ = 7; break; + case 7: + var $28=$i; + var $29=((($28)+(1))|0); + $i=$29; + __label__ = 3; break; + case 8: + var $31=$3; + var $32=_code_genstring($31); + $str=$32; + var $33=$2; + var $34=$3; + var $35=_ir_builder_filenames_add($33, $34); + if ($35) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 13; break; + case 10: + var $38=$2; + var $39=$str; + var $40=_ir_builder_filestrings_add($38, $39); + if ($40) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $42=$2; + var $43=(($42+44)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44)-(1))|0); + HEAP32[(($43)>>2)]=$45; + __label__ = 12; break; + case 12: + var $47=$str; + $1=$47; + __label__ = 13; break; + case 13: + var $49=$1; + ; + return $49; + default: assert(0, "bad label: " + __label__); + } +} +_ir_builder_filestring["X"]=1; + +function _ir_block_life_prop_previous($self, $prev, $changed) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + $2=$self; + $3=$prev; + $4=$changed; + $i=0; + __label__ = 3; break; + case 3: + var $6=$i; + var $7=$2; + var $8=(($7+56)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)>>>0) < (($9)>>>0); + if ($10) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + var $12=$3; + var $13=$i; + var $14=$2; + var $15=(($14+52)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16+($13<<2))|0); + var $18=HEAP32[(($17)>>2)]; + var $19=_ir_block_living_find($12, $18, 0); + if ($19) { __label__ = 8; break; } else { __label__ = 5; break; } + case 5: + var $21=$2; + var $22=$i; + var $23=_ir_block_living_remove($21, $22); + if ($23) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + $1=0; + __label__ = 19; break; + case 7: + var $26=$i; + var $27=((($26)-(1))|0); + $i=$27; + __label__ = 8; break; + case 8: + __label__ = 9; break; + case 9: + var $30=$i; + var $31=((($30)+(1))|0); + $i=$31; + __label__ = 3; break; + case 10: + $i=0; + __label__ = 11; break; + case 11: + var $34=$i; + var $35=$3; + var $36=(($35+56)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($34)>>>0) < (($37)>>>0); + if ($38) { __label__ = 12; break; } else { __label__ = 18; break; } + case 12: + var $40=$2; + var $41=$i; + var $42=$3; + var $43=(($42+52)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=(($44+($41<<2))|0); + var $46=HEAP32[(($45)>>2)]; + var $47=_ir_block_living_find($40, $46, 0); + if ($47) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + __label__ = 17; break; + case 14: + var $50=$2; + var $51=$i; + var $52=$3; + var $53=(($52+52)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=(($54+($51<<2))|0); + var $56=HEAP32[(($55)>>2)]; + var $57=_ir_block_living_add($50, $56); + if ($57) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 19; break; + case 16: + __label__ = 17; break; + case 17: + var $61=$i; + var $62=((($61)+(1))|0); + $i=$62; + __label__ = 11; break; + case 18: + $1=1; + __label__ = 19; break; + case 19: + var $65=$1; + ; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_life_prop_previous["X"]=1; + +function _ir_block_living_add_instr($self, $eid) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $changed; + var $tempbool; + $1=$self; + $2=$eid; + $changed=0; + $i=0; + __label__ = 3; break; + case 3: + var $4=$i; + var $5=$1; + var $6=(($5+56)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)|0)!=(($7)|0); + if ($8) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $10=$i; + var $11=$1; + var $12=(($11+52)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+($10<<2))|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$2; + var $17=_ir_value_life_merge($15, $16); + var $18=(($17)&1); + $tempbool=$18; + var $19=$changed; + var $20=(($19) & 1); + if ($20) { var $25 = 1;__label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $22=$tempbool; + var $23=(($22) & 1); + var $25 = $23;__label__ = 6; break; + case 6: + var $25; + var $26=(($25)&1); + $changed=$26; + __label__ = 7; break; + case 7: + var $28=$i; + var $29=((($28)+(1))|0); + $i=$29; + __label__ = 3; break; + case 8: + var $31=$changed; + var $32=(($31) & 1); + ; + return $32; + default: assert(0, "bad label: " + __label__); + } +} + + +function _ir_naive_phi_emit_store($block, $iid, $old, $what) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $instr; + var $i; + $2=$block; + $3=$iid; + $4=$old; + $5=$what; + var $6=$2; + var $7=$4; + var $8=$5; + var $9=_ir_block_create_store($6, $7, $8); + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 9; break; + case 4: + var $12=$2; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=((($14)-(1))|0); + var $16=$2; + var $17=(($16+16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+($15<<2))|0); + var $20=HEAP32[(($19)>>2)]; + $instr=$20; + var $21=$2; + var $22=(($21+20)|0); + var $23=HEAP32[(($22)>>2)]; + $i=$23; + __label__ = 5; break; + case 5: + var $25=$i; + var $26=$3; + var $27=(($25)>>>0) > (($26)>>>0); + if ($27) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $29=$i; + var $30=((($29)-(1))|0); + var $31=$2; + var $32=(($31+16)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33+($30<<2))|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$i; + var $37=$2; + var $38=(($37+16)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($39+($36<<2))|0); + HEAP32[(($40)>>2)]=$35; + __label__ = 7; break; + case 7: + var $42=$i; + var $43=((($42)-(1))|0); + $i=$43; + __label__ = 5; break; + case 8: + var $45=$instr; + var $46=$i; + var $47=$2; + var $48=(($47+16)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($49+($46<<2))|0); + HEAP32[(($50)>>2)]=$45; + $1=1; + __label__ = 9; break; + case 9: + var $52=$1; + ; + return $52; + default: assert(0, "bad label: " + __label__); + } +} +_ir_naive_phi_emit_store["X"]=1; + +function _ir_block_delete_quick($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$self; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 545, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + $i=0; + __label__ = 5; break; + case 5: + var $12=$i; + var $13=$1; + var $14=(($13+20)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)|0)!=(($15)|0); + if ($16) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $18=$i; + var $19=$1; + var $20=(($19+16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21+($18<<2))|0); + var $23=HEAP32[(($22)>>2)]; + _ir_instr_delete_quick($23); + __label__ = 7; break; + case 7: + var $25=$i; + var $26=((($25)+(1))|0); + $i=$26; + __label__ = 5; break; + case 8: + var $28=$1; + var $29=(($28+16)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $33=$1; + var $34=(($33+16)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=$35; + _util_memory_d($36, 548, ((STRING_TABLE.__str9222)|0)); + __label__ = 10; break; + case 10: + var $38=$1; + var $39=(($38+16)|0); + HEAP32[(($39)>>2)]=0; + var $40=$1; + var $41=(($40+20)|0); + HEAP32[(($41)>>2)]=0; + var $42=$1; + var $43=(($42+24)|0); + HEAP32[(($43)>>2)]=0; + var $44=$1; + var $45=(($44+28)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($46)|0)!=0; + if ($47) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $49=$1; + var $50=(($49+28)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=$51; + _util_memory_d($52, 549, ((STRING_TABLE.__str9222)|0)); + __label__ = 12; break; + case 12: + var $54=$1; + var $55=(($54+28)|0); + HEAP32[(($55)>>2)]=0; + var $56=$1; + var $57=(($56+32)|0); + HEAP32[(($57)>>2)]=0; + var $58=$1; + var $59=(($58+36)|0); + HEAP32[(($59)>>2)]=0; + var $60=$1; + var $61=(($60+40)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62)|0)!=0; + if ($63) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $65=$1; + var $66=(($65+40)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + _util_memory_d($68, 550, ((STRING_TABLE.__str9222)|0)); + __label__ = 14; break; + case 14: + var $70=$1; + var $71=(($70+40)|0); + HEAP32[(($71)>>2)]=0; + var $72=$1; + var $73=(($72+44)|0); + HEAP32[(($73)>>2)]=0; + var $74=$1; + var $75=(($74+48)|0); + HEAP32[(($75)>>2)]=0; + var $76=$1; + var $77=(($76+52)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($78)|0)!=0; + if ($79) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $81=$1; + var $82=(($81+52)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=$83; + _util_memory_d($84, 551, ((STRING_TABLE.__str9222)|0)); + __label__ = 16; break; + case 16: + var $86=$1; + var $87=(($86+52)|0); + HEAP32[(($87)>>2)]=0; + var $88=$1; + var $89=(($88+56)|0); + HEAP32[(($89)>>2)]=0; + var $90=$1; + var $91=(($90+60)|0); + HEAP32[(($91)>>2)]=0; + var $92=$1; + var $93=$92; + _util_memory_d($93, 552, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_ir_block_delete_quick["X"]=1; + +function _ir_instr_delete_quick($self) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$self; + var $2=$1; + var $3=(($2+32)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7+32)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=$9; + _util_memory_d($10, 607, ((STRING_TABLE.__str9222)|0)); + __label__ = 4; break; + case 4: + var $12=$1; + var $13=(($12+32)|0); + HEAP32[(($13)>>2)]=0; + var $14=$1; + var $15=(($14+36)|0); + HEAP32[(($15)>>2)]=0; + var $16=$1; + var $17=(($16+40)|0); + HEAP32[(($17)>>2)]=0; + var $18=$1; + var $19=(($18+44)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20)|0)!=0; + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $23=$1; + var $24=(($23+44)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=$25; + _util_memory_d($26, 608, ((STRING_TABLE.__str9222)|0)); + __label__ = 6; break; + case 6: + var $28=$1; + var $29=(($28+44)|0); + HEAP32[(($29)>>2)]=0; + var $30=$1; + var $31=(($30+48)|0); + HEAP32[(($31)>>2)]=0; + var $32=$1; + var $33=(($32+52)|0); + HEAP32[(($33)>>2)]=0; + var $34=$1; + var $35=$34; + _util_memory_d($35, 609, ((STRING_TABLE.__str9222)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _token_value_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+8)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+12)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+12)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+12)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+12)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27)|0); + var $29=_util_memory_a($28, 9, ((STRING_TABLE.__str385)|0)); + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$2; + var $36=(($35+4)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$2; + var $39=(($38+8)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40)|0); + assert($41 % 1 === 0, 'memcpy given ' + $41 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($34, $37, $41, 1); + var $42=$2; + var $43=(($42+4)|0); + var $44=HEAP32[(($43)>>2)]; + _util_memory_d($44, 9, ((STRING_TABLE.__str385)|0)); + var $45=$reall; + var $46=$2; + var $47=(($46+4)|0); + HEAP32[(($47)>>2)]=$45; + __label__ = 9; break; + case 9: + var $49=$3; + var $50=$2; + var $51=(($50+8)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=((($52)+(1))|0); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+4)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+$52)|0); + HEAP8[($57)]=$49; + $1=1; + __label__ = 10; break; + case 10: + var $59=$1; + ; + return $59; + default: assert(0, "bad label: " + __label__); + } +} +_token_value_add["X"]=1; + +function _lex_file_frames_add($self, $f_0, $f_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=$2; + var $6=(($5+340)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+344)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+344)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+344)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+344)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+344)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=((($28<<3))|0); + var $30=_util_memory_a($29, 10, ((STRING_TABLE.__str385)|0)); + var $31=$30; + $reall=$31; + var $32=$reall; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $36=$reall; + var $37=$36; + var $38=$2; + var $39=(($38+336)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + var $42=$2; + var $43=(($42+340)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44<<3))|0); + assert($45 % 1 === 0, 'memcpy given ' + $45 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $41, $45, 4); + var $46=$2; + var $47=(($46+336)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + _util_memory_d($49, 10, ((STRING_TABLE.__str385)|0)); + var $50=$reall; + var $51=$2; + var $52=(($51+336)|0); + HEAP32[(($52)>>2)]=$50; + __label__ = 9; break; + case 9: + var $54=$2; + var $55=(($54+340)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+336)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<3))|0); + var $62=$61; + var $63=$f; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($62)>>2)]=HEAP32[(($63)>>2)];HEAP32[((($62)+(4))>>2)]=HEAP32[((($63)+(4))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_lex_file_frames_add["X"]=1; + +function _lex_filenames_add($element) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $temp; + $2=$element; + $temp=0; + var $3=HEAP32[((_lex_filenames_elements)>>2)]; + var $4=HEAP32[((_lex_filenames_allocated)>>2)]; + var $5=(($3)|0)==(($4)|0); + if ($5) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $7=HEAP32[((_lex_filenames_allocated)>>2)]; + var $8=(($7)|0)==0; + if ($8) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_lex_filenames_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $11=HEAP32[((_lex_filenames_allocated)>>2)]; + var $12=((($11<<1))|0); + HEAP32[((_lex_filenames_allocated)>>2)]=$12; + __label__ = 6; break; + case 6: + var $14=HEAP32[((_lex_filenames_allocated)>>2)]; + var $15=((($14<<2))|0); + var $16=_util_memory_a($15, 12, ((STRING_TABLE.__str385)|0)); + $temp=$16; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $19=$temp; + _util_memory_d($19, 12, ((STRING_TABLE.__str385)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $21=$temp; + var $22=HEAP32[((_lex_filenames_data)>>2)]; + var $23=$22; + var $24=HEAP32[((_lex_filenames_elements)>>2)]; + var $25=((($24<<2))|0); + assert($25 % 1 === 0, 'memcpy given ' + $25 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($21, $23, $25, 1); + var $26=HEAP32[((_lex_filenames_data)>>2)]; + var $27=$26; + _util_memory_d($27, 12, ((STRING_TABLE.__str385)|0)); + var $28=$temp; + var $29=$28; + HEAP32[((_lex_filenames_data)>>2)]=$29; + __label__ = 9; break; + case 9: + var $31=$2; + var $32=HEAP32[((_lex_filenames_elements)>>2)]; + var $33=HEAP32[((_lex_filenames_data)>>2)]; + var $34=(($33+($32<<2))|0); + HEAP32[(($34)>>2)]=$31; + var $35=HEAP32[((_lex_filenames_elements)>>2)]; + var $36=((($35)+(1))|0); + HEAP32[((_lex_filenames_elements)>>2)]=$36; + $1=$35; + __label__ = 10; break; + case 10: + var $38=$1; + ; + return $38; + default: assert(0, "bad label: " + __label__); + } +} +_lex_filenames_add["X"]=1; + +function _lexerror($lex, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $2; + var $ap=__stackBase__; + $1=$lex; + $2=$fmt; + var $3=$ap; + HEAP32[(($3)>>2)]=arguments[_lexerror.length]; + var $4=$1; + var $5=(($4+16)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$1; + var $8=(($7+24)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=$2; + var $11=HEAP32[(($ap)>>2)]; + _vprintmsg(2, $6, $9, ((STRING_TABLE.__str1386)|0), $10, $11); + var $12=$ap; + ; + STACKTOP = __stackBase__; + return; +} + + +function _lexwarn($lex, $warntype, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $ap=__stackBase__; + var $lvl; + $2=$lex; + $3=$warntype; + $4=$fmt; + $lvl=1; + var $5=$3; + var $6=((((($5)|0))/(32))&-1); + var $7=((_opts_warn+($6<<2))|0); + var $8=HEAP32[(($7)>>2)]; + var $9=$3; + var $10=((($9)|0))%(32); + var $11=1 << $10; + var $12=$8 & $11; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $16=HEAP8[(_opts_werror)]; + var $17=(($16) & 1); + if ($17) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $lvl=2; + __label__ = 6; break; + case 6: + var $20=$ap; + HEAP32[(($20)>>2)]=arguments[_lexwarn.length]; + var $21=$lvl; + var $22=$2; + var $23=(($22+16)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$2; + var $26=(($25+24)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$4; + var $29=HEAP32[(($ap)>>2)]; + _vprintmsg($21, $24, $27, ((STRING_TABLE.__str2387)|0), $28, $29); + var $30=$ap; + ; + var $31=HEAP8[(_opts_werror)]; + var $32=(($31) & 1); + $1=$32; + __label__ = 7; break; + case 7: + var $34=$1; + STACKTOP = __stackBase__; + return $34; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_open($file) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $lex; + var $in; + $2=$file; + var $3=$2; + var $4=_util_fopen($3, ((STRING_TABLE.__str3388)|0)); + $in=$4; + var $5=$in; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $8=$2; + _lexerror(0, ((STRING_TABLE.__str4389)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$8,tempInt)); + $1=0; + __label__ = 7; break; + case 4: + var $10=_util_memory_a(352, 144, ((STRING_TABLE.__str385)|0)); + var $11=$10; + $lex=$11; + var $12=$lex; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $15=$in; + var $16=_fclose($15); + _lexerror(0, ((STRING_TABLE.__str5390)|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)); + $1=0; + __label__ = 7; break; + case 6: + var $18=$lex; + var $19=$18; + for (var $$dest = $19>>2, $$stop = $$dest + 88; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $20=$in; + var $21=$lex; + var $22=(($21)|0); + HEAP32[(($22)>>2)]=$20; + var $23=$2; + var $24=_util_strdup($23); + var $25=$lex; + var $26=(($25+16)|0); + HEAP32[(($26)>>2)]=$24; + var $27=$lex; + var $28=(($27+20)|0); + HEAP32[(($28)>>2)]=1; + var $29=$lex; + var $30=(($29+284)|0); + HEAP32[(($30)>>2)]=0; + var $31=$lex; + var $32=(($31+288)|0); + HEAP8[($32)]=0; + var $33=$lex; + var $34=(($33+16)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=_lex_filenames_add($35); + var $37=$lex; + $1=$37; + __label__ = 7; break; + case 7: + var $39=$1; + STACKTOP = __stackBase__; + return $39; + default: assert(0, "bad label: " + __label__); + } +} +_lex_open["X"]=1; + +function _lex_open_string($str, $len, $name) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $lex; + $2=$str; + $3=$len; + $4=$name; + var $5=_util_memory_a(352, 169, ((STRING_TABLE.__str385)|0)); + var $6=$5; + $lex=$6; + var $7=$lex; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + _lexerror(0, ((STRING_TABLE.__str5390)|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)); + $1=0; + __label__ = 8; break; + case 4: + var $11=$lex; + var $12=$11; + for (var $$dest = $12>>2, $$stop = $$dest + 88; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $13=$lex; + var $14=(($13)|0); + HEAP32[(($14)>>2)]=0; + var $15=$2; + var $16=$lex; + var $17=(($16+4)|0); + HEAP32[(($17)>>2)]=$15; + var $18=$3; + var $19=$lex; + var $20=(($19+8)|0); + HEAP32[(($20)>>2)]=$18; + var $21=$lex; + var $22=(($21+12)|0); + HEAP32[(($22)>>2)]=0; + var $23=$4; + var $24=(($23)|0)!=0; + if ($24) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $26=$4; + var $29 = $26;__label__ = 7; break; + case 6: + var $29 = ((STRING_TABLE.__str6391)|0);__label__ = 7; break; + case 7: + var $29; + var $30=_util_strdup($29); + var $31=$lex; + var $32=(($31+16)|0); + HEAP32[(($32)>>2)]=$30; + var $33=$lex; + var $34=(($33+20)|0); + HEAP32[(($34)>>2)]=1; + var $35=$lex; + var $36=(($35+284)|0); + HEAP32[(($36)>>2)]=0; + var $37=$lex; + var $38=(($37+288)|0); + HEAP8[($38)]=0; + var $39=$lex; + var $40=(($39+16)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=_lex_filenames_add($41); + var $43=$lex; + $1=$43; + __label__ = 8; break; + case 8: + var $45=$1; + STACKTOP = __stackBase__; + return $45; + default: assert(0, "bad label: " + __label__); + } +} +_lex_open_string["X"]=1; + +function _lex_cleanup() { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $i; + $i=0; + __label__ = 3; break; + case 3: + var $2=$i; + var $3=HEAP32[((_lex_filenames_elements)>>2)]; + var $4=(($2)>>>0) < (($3)>>>0); + if ($4) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $6=$i; + var $7=HEAP32[((_lex_filenames_data)>>2)]; + var $8=(($7+($6<<2))|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 197, ((STRING_TABLE.__str385)|0)); + __label__ = 5; break; + case 5: + var $11=$i; + var $12=((($11)+(1))|0); + $i=$12; + __label__ = 3; break; + case 6: + var $14=HEAP32[((_lex_filenames_data)>>2)]; + var $15=$14; + _util_memory_d($15, 198, ((STRING_TABLE.__str385)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_close($lex) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$lex; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=$1; + var $5=(($4+340)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) < (($6)>>>0); + if ($7) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $9=$i; + var $10=$1; + var $11=(($10+336)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12+($9<<3))|0); + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + _util_memory_d($15, 205, ((STRING_TABLE.__str385)|0)); + __label__ = 5; break; + case 5: + var $17=$i; + var $18=((($17)+(1))|0); + $i=$18; + __label__ = 3; break; + case 6: + var $20=$1; + var $21=(($20+336)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22)|0)!=0; + if ($23) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $25=$1; + var $26=(($25+336)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$27; + _util_memory_d($28, 206, ((STRING_TABLE.__str385)|0)); + __label__ = 8; break; + case 8: + var $30=$1; + var $31=(($30+336)|0); + HEAP32[(($31)>>2)]=0; + var $32=$1; + var $33=(($32+340)|0); + HEAP32[(($33)>>2)]=0; + var $34=$1; + var $35=(($34+344)|0); + HEAP32[(($35)>>2)]=0; + var $36=$1; + var $37=(($36+348)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=(($38)|0)!=0; + if ($39) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $41=$1; + var $42=(($41+348)|0); + var $43=HEAP32[(($42)>>2)]; + _util_memory_d($43, 209, ((STRING_TABLE.__str385)|0)); + __label__ = 10; break; + case 10: + var $45=$1; + var $46=(($45)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($47)|0)!=0; + if ($48) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $50=$1; + var $51=(($50)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=_fclose($52); + __label__ = 12; break; + case 12: + var $55=$1; + var $56=(($55+292)|0); + var $57=(($56+4)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58)|0)!=0; + if ($59) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $61=$1; + var $62=(($61+292)|0); + var $63=(($62+4)|0); + var $64=HEAP32[(($63)>>2)]; + _util_memory_d($64, 217, ((STRING_TABLE.__str385)|0)); + __label__ = 14; break; + case 14: + var $66=$1; + var $67=(($66+292)|0); + var $68=(($67+4)|0); + HEAP32[(($68)>>2)]=0; + var $69=$1; + var $70=(($69+292)|0); + var $71=(($70+8)|0); + HEAP32[(($71)>>2)]=0; + var $72=$1; + var $73=(($72+292)|0); + var $74=(($73+12)|0); + HEAP32[(($74)>>2)]=0; + var $75=$1; + var $76=$75; + _util_memory_d($76, 220, ((STRING_TABLE.__str385)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_lex_close["X"]=1; + +function _lex_do($lex) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ch; + var $nextch; + var $v; + var $frame; + var $rc; + var $rc1; + var $m=__stackBase__; + var $frame2; + var $v3; + $2=$lex; + var $3=$2; + _lex_token_new($3); + var $4=$2; + var $5=_lex_skipwhite($4); + $ch=$5; + var $6=$2; + var $7=(($6+20)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=$2; + var $10=(($9+24)|0); + HEAP32[(($10)>>2)]=$8; + var $11=$2; + var $12=(($11+24)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$2; + var $15=(($14+292)|0); + var $16=(($15+28)|0); + var $17=(($16+4)|0); + HEAP32[(($17)>>2)]=$13; + var $18=$2; + var $19=(($18+16)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=$2; + var $22=(($21+292)|0); + var $23=(($22+28)|0); + var $24=(($23)|0); + HEAP32[(($24)>>2)]=$20; + var $25=$2; + var $26=(($25+328)|0); + var $27=(($26+2)|0); + var $28=HEAP8[($27)]; + var $29=(($28) & 1); + if ($29) { __label__ = 3; break; } else { __label__ = 7; break; } + case 3: + var $31=$ch; + var $32=(($31)|0)==139; + if ($32) { __label__ = 6; break; } else { __label__ = 4; break; } + case 4: + var $34=$ch; + var $35=(($34)|0)==140; + if ($35) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $37=$ch; + var $38=(($37)|0)==143; + if ($38) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $40=$ch; + var $41=$2; + var $42=(($41+292)|0); + var $43=(($42)|0); + HEAP32[(($43)>>2)]=$40; + $1=$40; + __label__ = 256; break; + case 7: + var $45=$2; + var $46=(($45+288)|0); + var $47=HEAP8[($46)]; + var $48=(($47) & 1); + if ($48) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $50=$2; + var $51=(($50+292)|0); + var $52=(($51)|0); + HEAP32[(($52)>>2)]=143; + $1=143; + __label__ = 256; break; + case 9: + var $54=$ch; + var $55=(($54)|0)==-1; + if ($55) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $57=$2; + var $58=(($57+288)|0); + HEAP8[($58)]=1; + var $59=$2; + var $60=(($59+292)|0); + var $61=(($60)|0); + HEAP32[(($61)>>2)]=141; + $1=141; + __label__ = 256; break; + case 11: + var $63=$ch; + var $64=(($63)|0)==36; + if ($64) { __label__ = 12; break; } else { __label__ = 99; break; } + case 12: + var $66=$2; + var $67=_lex_getch($66); + $ch=$67; + var $68=$ch; + var $69=_isident_start($68); + if ($69) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + var $71=$2; + _lexerror($71, ((STRING_TABLE.__str7392)|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)); + var $72=$2; + var $73=_lex_do($72); + $1=$73; + __label__ = 256; break; + case 14: + var $75=$2; + var $76=$ch; + var $77=_lex_tokench($75, $76); + if ($77) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $79=$2; + var $80=(($79+292)|0); + var $81=(($80)|0); + HEAP32[(($81)>>2)]=143; + $1=143; + __label__ = 256; break; + case 16: + var $83=$2; + var $84=_lex_finish_ident($83); + if ($84) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $86=$2; + var $87=(($86+292)|0); + var $88=(($87)|0); + HEAP32[(($88)>>2)]=142; + $1=142; + __label__ = 256; break; + case 18: + var $90=$2; + var $91=_lex_endtoken($90); + if ($91) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + var $93=$2; + var $94=(($93+292)|0); + var $95=(($94)|0); + HEAP32[(($95)>>2)]=143; + $1=143; + __label__ = 256; break; + case 20: + var $97=$2; + var $98=(($97+292)|0); + var $99=(($98+4)|0); + var $100=HEAP32[(($99)>>2)]; + $v=$100; + var $101=$v; + var $102=_strcmp($101, ((STRING_TABLE.__str8393)|0)); + var $103=(($102)|0)!=0; + if ($103) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $105=$v; + var $106=_strcmp($105, ((STRING_TABLE.__str9394)|0)); + var $107=(($106)|0)!=0; + if ($107) { __label__ = 25; break; } else { __label__ = 22; break; } + case 22: + var $109=$2; + var $110=_lex_finish_frames($109); + if ($110) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $112=$2; + var $113=(($112+292)|0); + var $114=(($113)|0); + HEAP32[(($114)>>2)]=142; + $1=142; + __label__ = 256; break; + case 24: + var $116=$2; + var $117=_lex_do($116); + $1=$117; + __label__ = 256; break; + case 25: + var $119=$v; + var $120=_strcmp($119, ((STRING_TABLE.__str10395)|0)); + var $121=(($120)|0)!=0; + if ($121) { __label__ = 39; break; } else { __label__ = 26; break; } + case 26: + var $123=$2; + var $124=_lex_getch($123); + $ch=$124; + __label__ = 27; break; + case 27: + var $126=$ch; + var $127=(($126)|0)!=-1; + if ($127) { __label__ = 28; break; } else { var $136 = 0;__label__ = 30; break; } + case 28: + var $129=$ch; + var $130=_isspace($129); + var $131=(($130)|0)!=0; + if ($131) { __label__ = 29; break; } else { var $136 = 0;__label__ = 30; break; } + case 29: + var $133=$ch; + var $134=(($133)|0)!=10; + var $136 = $134;__label__ = 30; break; + case 30: + var $136; + if ($136) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + var $138=$2; + var $139=_lex_getch($138); + $ch=$139; + __label__ = 27; break; + case 32: + var $141=$ch; + var $142=_isdigit($141); + var $143=(($142)|0)!=0; + if ($143) { __label__ = 34; break; } else { __label__ = 33; break; } + case 33: + var $145=$2; + _lexerror($145, ((STRING_TABLE.__str11396)|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)); + var $146=$2; + var $147=_lex_do($146); + $1=$147; + __label__ = 256; break; + case 34: + var $149=$2; + _lex_token_new($149); + var $150=$2; + var $151=$ch; + var $152=_lex_finish_digit($150, $151); + var $153=$2; + var $154=(($153+292)|0); + var $155=(($154)|0); + HEAP32[(($155)>>2)]=$152; + var $156=$2; + var $157=_lex_endtoken($156); + if ($157) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + var $159=$2; + var $160=(($159+292)|0); + var $161=(($160)|0); + HEAP32[(($161)>>2)]=143; + $1=143; + __label__ = 256; break; + case 36: + var $163=$2; + var $164=(($163+292)|0); + var $165=(($164)|0); + var $166=HEAP32[(($165)>>2)]; + var $167=(($166)|0)!=137; + if ($167) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + var $169=$2; + _lexerror($169, ((STRING_TABLE.__str11396)|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)); + var $170=$2; + var $171=_lex_do($170); + $1=$171; + __label__ = 256; break; + case 38: + var $173=$2; + var $174=(($173+292)|0); + var $175=(($174+16)|0); + var $176=$175; + var $177=HEAP32[(($176)>>2)]; + var $178=$2; + var $179=(($178+332)|0); + HEAP32[(($179)>>2)]=$177; + var $180=$2; + var $181=_lex_do($180); + $1=$181; + __label__ = 256; break; + case 39: + var $183=$v; + var $184=_strcmp($183, ((STRING_TABLE.__str12397)|0)); + var $185=(($184)|0)!=0; + if ($185) { __label__ = 51; break; } else { __label__ = 40; break; } + case 40: + var $187=$2; + _lex_token_new($187); + var $188=$2; + var $189=_lex_parse_frame($188); + $rc=$189; + var $190=$rc; + var $191=(($190)|0) > 0; + if ($191) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + var $193=$2; + _lexerror($193, ((STRING_TABLE.__str13398)|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)); + var $194=$2; + var $195=_lex_do($194); + $1=$195; + __label__ = 256; break; + case 42: + var $197=$rc; + var $198=(($197)|0) < 0; + if ($198) { __label__ = 43; break; } else { __label__ = 44; break; } + case 43: + var $200=$2; + var $201=(($200+292)|0); + var $202=(($201)|0); + HEAP32[(($202)>>2)]=143; + $1=143; + __label__ = 256; break; + case 44: + var $204=$2; + var $205=(($204+292)|0); + var $206=(($205+4)|0); + var $207=HEAP32[(($206)>>2)]; + $v=$207; + $frame=0; + __label__ = 45; break; + case 45: + var $209=$frame; + var $210=$2; + var $211=(($210+340)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=(($209)>>>0) < (($212)>>>0); + if ($213) { __label__ = 46; break; } else { __label__ = 50; break; } + case 46: + var $215=$v; + var $216=$frame; + var $217=$2; + var $218=(($217+336)|0); + var $219=HEAP32[(($218)>>2)]; + var $220=(($219+($216<<3))|0); + var $221=(($220)|0); + var $222=HEAP32[(($221)>>2)]; + var $223=_strcmp($215, $222); + var $224=(($223)|0)!=0; + if ($224) { __label__ = 48; break; } else { __label__ = 47; break; } + case 47: + var $226=$frame; + var $227=$2; + var $228=(($227+336)|0); + var $229=HEAP32[(($228)>>2)]; + var $230=(($229+($226<<3))|0); + var $231=(($230+4)|0); + var $232=HEAP32[(($231)>>2)]; + var $233=$2; + var $234=(($233+332)|0); + HEAP32[(($234)>>2)]=$232; + var $235=$2; + var $236=_lex_do($235); + $1=$236; + __label__ = 256; break; + case 48: + __label__ = 49; break; + case 49: + var $239=$frame; + var $240=((($239)+(1))|0); + $frame=$240; + __label__ = 45; break; + case 50: + var $242=$2; + var $243=$v; + _lexerror($242, ((STRING_TABLE.__str14399)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$243,tempInt)); + var $244=$2; + var $245=_lex_do($244); + $1=$245; + __label__ = 256; break; + case 51: + var $247=$v; + var $248=_strcmp($247, ((STRING_TABLE.__str15400)|0)); + var $249=(($248)|0)!=0; + if ($249) { __label__ = 67; break; } else { __label__ = 52; break; } + case 52: + var $251=$2; + _lex_token_new($251); + var $252=$2; + var $253=_lex_parse_frame($252); + $rc1=$253; + var $254=$rc1; + var $255=(($254)|0) > 0; + if ($255) { __label__ = 53; break; } else { __label__ = 54; break; } + case 53: + var $257=$2; + _lexerror($257, ((STRING_TABLE.__str13398)|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)); + var $258=$2; + var $259=_lex_do($258); + $1=$259; + __label__ = 256; break; + case 54: + var $261=$rc1; + var $262=(($261)|0) < 0; + if ($262) { __label__ = 55; break; } else { __label__ = 56; break; } + case 55: + var $264=$2; + var $265=(($264+292)|0); + var $266=(($265)|0); + HEAP32[(($266)>>2)]=143; + $1=143; + __label__ = 256; break; + case 56: + var $268=$2; + var $269=(($268+292)|0); + var $270=(($269+4)|0); + var $271=HEAP32[(($270)>>2)]; + $v=$271; + var $272=$2; + var $273=(($272+348)|0); + var $274=HEAP32[(($273)>>2)]; + var $275=(($274)|0)!=0; + if ($275) { __label__ = 57; break; } else { __label__ = 60; break; } + case 57: + var $277=$2; + var $278=(($277+332)|0); + var $279=HEAP32[(($278)>>2)]; + var $280=(($m+4)|0); + HEAP32[(($280)>>2)]=$279; + var $281=$2; + var $282=(($281+348)|0); + var $283=HEAP32[(($282)>>2)]; + var $284=(($m)|0); + HEAP32[(($284)>>2)]=$283; + var $285=$2; + var $286=(($285+348)|0); + HEAP32[(($286)>>2)]=0; + var $287=$2; + var $288=(($m)|0); + var $289=HEAP32[(($288)>>2)]; + var $290=(($m+4)|0); + var $291=HEAP32[(($290)>>2)]; + var $292=_lex_file_frames_add($287, $289, $291); + if ($292) { __label__ = 59; break; } else { __label__ = 58; break; } + case 58: + var $294=$2; + _lexerror($294, ((STRING_TABLE.__str16401)|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)); + var $295=$2; + var $296=(($295+292)|0); + var $297=(($296)|0); + HEAP32[(($297)>>2)]=143; + $1=143; + __label__ = 256; break; + case 59: + __label__ = 60; break; + case 60: + var $300=$2; + var $301=(($300+292)|0); + var $302=(($301+4)|0); + var $303=HEAP32[(($302)>>2)]; + var $304=$2; + var $305=(($304+348)|0); + HEAP32[(($305)>>2)]=$303; + var $306=$2; + var $307=(($306+292)|0); + var $308=(($307+4)|0); + HEAP32[(($308)>>2)]=0; + var $309=$2; + var $310=(($309+292)|0); + var $311=(($310+8)|0); + HEAP32[(($311)>>2)]=0; + var $312=$2; + var $313=(($312+292)|0); + var $314=(($313+12)|0); + HEAP32[(($314)>>2)]=0; + $frame=0; + __label__ = 61; break; + case 61: + var $316=$frame; + var $317=$2; + var $318=(($317+340)|0); + var $319=HEAP32[(($318)>>2)]; + var $320=(($316)>>>0) < (($319)>>>0); + if ($320) { __label__ = 62; break; } else { __label__ = 66; break; } + case 62: + var $322=$v; + var $323=$frame; + var $324=$2; + var $325=(($324+336)|0); + var $326=HEAP32[(($325)>>2)]; + var $327=(($326+($323<<3))|0); + var $328=(($327)|0); + var $329=HEAP32[(($328)>>2)]; + var $330=_strcmp($322, $329); + var $331=(($330)|0)!=0; + if ($331) { __label__ = 64; break; } else { __label__ = 63; break; } + case 63: + var $333=$frame; + var $334=$2; + var $335=(($334+336)|0); + var $336=HEAP32[(($335)>>2)]; + var $337=(($336+($333<<3))|0); + var $338=(($337+4)|0); + var $339=HEAP32[(($338)>>2)]; + var $340=$2; + var $341=(($340+332)|0); + HEAP32[(($341)>>2)]=$339; + __label__ = 66; break; + case 64: + __label__ = 65; break; + case 65: + var $344=$frame; + var $345=((($344)+(1))|0); + $frame=$345; + __label__ = 61; break; + case 66: + var $347=$2; + var $348=_lex_do($347); + $1=$348; + __label__ = 256; break; + case 67: + var $350=$v; + var $351=_strcmp($350, ((STRING_TABLE.__str17402)|0)); + var $352=(($351)|0)!=0; + if ($352) { __label__ = 80; break; } else { __label__ = 68; break; } + case 68: + $frame2=0; + __label__ = 69; break; + case 69: + var $355=$frame2; + var $356=$2; + var $357=(($356+340)|0); + var $358=HEAP32[(($357)>>2)]; + var $359=(($355)>>>0) < (($358)>>>0); + if ($359) { __label__ = 70; break; } else { __label__ = 72; break; } + case 70: + var $361=$frame2; + var $362=$2; + var $363=(($362+336)|0); + var $364=HEAP32[(($363)>>2)]; + var $365=(($364+($361<<3))|0); + var $366=(($365)|0); + var $367=HEAP32[(($366)>>2)]; + _util_memory_d($367, 858, ((STRING_TABLE.__str385)|0)); + __label__ = 71; break; + case 71: + var $369=$frame2; + var $370=((($369)+(1))|0); + $frame2=$370; + __label__ = 69; break; + case 72: + var $372=$2; + var $373=(($372+336)|0); + var $374=HEAP32[(($373)>>2)]; + var $375=(($374)|0)!=0; + if ($375) { __label__ = 73; break; } else { __label__ = 74; break; } + case 73: + var $377=$2; + var $378=(($377+336)|0); + var $379=HEAP32[(($378)>>2)]; + var $380=$379; + _util_memory_d($380, 859, ((STRING_TABLE.__str385)|0)); + __label__ = 74; break; + case 74: + var $382=$2; + var $383=(($382+336)|0); + HEAP32[(($383)>>2)]=0; + var $384=$2; + var $385=(($384+340)|0); + HEAP32[(($385)>>2)]=0; + var $386=$2; + var $387=(($386+344)|0); + HEAP32[(($387)>>2)]=0; + var $388=$2; + var $389=_lex_getch($388); + $ch=$389; + __label__ = 75; break; + case 75: + var $391=$ch; + var $392=(($391)|0)!=-1; + if ($392) { __label__ = 76; break; } else { var $397 = 0;__label__ = 77; break; } + case 76: + var $394=$ch; + var $395=(($394)|0)!=10; + var $397 = $395;__label__ = 77; break; + case 77: + var $397; + if ($397) { __label__ = 78; break; } else { __label__ = 79; break; } + case 78: + var $399=$2; + var $400=_lex_getch($399); + $ch=$400; + __label__ = 75; break; + case 79: + var $402=$2; + var $403=_lex_do($402); + $1=$403; + __label__ = 256; break; + case 80: + var $405=$v; + var $406=_strcmp($405, ((STRING_TABLE.__str18403)|0)); + var $407=(($406)|0)!=0; + if ($407) { __label__ = 81; break; } else { __label__ = 86; break; } + case 81: + var $409=$v; + var $410=_strcmp($409, ((STRING_TABLE.__str19404)|0)); + var $411=(($410)|0)!=0; + if ($411) { __label__ = 82; break; } else { __label__ = 86; break; } + case 82: + var $413=$v; + var $414=_strcmp($413, ((STRING_TABLE.__str20405)|0)); + var $415=(($414)|0)!=0; + if ($415) { __label__ = 83; break; } else { __label__ = 86; break; } + case 83: + var $417=$v; + var $418=_strcmp($417, ((STRING_TABLE.__str21406)|0)); + var $419=(($418)|0)!=0; + if ($419) { __label__ = 84; break; } else { __label__ = 86; break; } + case 84: + var $421=$v; + var $422=_strcmp($421, ((STRING_TABLE.__str22407)|0)); + var $423=(($422)|0)!=0; + if ($423) { __label__ = 85; break; } else { __label__ = 86; break; } + case 85: + var $425=$v; + var $426=_strcmp($425, ((STRING_TABLE.__str23408)|0)); + var $427=(($426)|0)!=0; + if ($427) { __label__ = 92; break; } else { __label__ = 86; break; } + case 86: + var $429=$2; + var $430=_lex_getch($429); + $ch=$430; + __label__ = 87; break; + case 87: + var $432=$ch; + var $433=(($432)|0)!=-1; + if ($433) { __label__ = 88; break; } else { var $438 = 0;__label__ = 89; break; } + case 88: + var $435=$ch; + var $436=(($435)|0)!=10; + var $438 = $436;__label__ = 89; break; + case 89: + var $438; + if ($438) { __label__ = 90; break; } else { __label__ = 91; break; } + case 90: + var $440=$2; + var $441=_lex_getch($440); + $ch=$441; + __label__ = 87; break; + case 91: + var $443=$2; + var $444=_lex_do($443); + $1=$444; + __label__ = 256; break; + case 92: + $frame=0; + __label__ = 93; break; + case 93: + var $447=$frame; + var $448=$2; + var $449=(($448+340)|0); + var $450=HEAP32[(($449)>>2)]; + var $451=(($447)>>>0) < (($450)>>>0); + if ($451) { __label__ = 94; break; } else { __label__ = 98; break; } + case 94: + var $453=$v; + var $454=$frame; + var $455=$2; + var $456=(($455+336)|0); + var $457=HEAP32[(($456)>>2)]; + var $458=(($457+($454<<3))|0); + var $459=(($458)|0); + var $460=HEAP32[(($459)>>2)]; + var $461=_strcmp($453, $460); + var $462=(($461)|0)!=0; + if ($462) { __label__ = 96; break; } else { __label__ = 95; break; } + case 95: + var $464=$frame; + var $465=$2; + var $466=(($465+336)|0); + var $467=HEAP32[(($466)>>2)]; + var $468=(($467+($464<<3))|0); + var $469=(($468+4)|0); + var $470=HEAP32[(($469)>>2)]; + var $471=$2; + var $472=(($471+292)|0); + var $473=(($472+16)|0); + var $474=$473; + HEAP32[(($474)>>2)]=$470; + var $475=$2; + var $476=(($475+292)|0); + var $477=(($476)|0); + HEAP32[(($477)>>2)]=137; + $1=137; + __label__ = 256; break; + case 96: + __label__ = 97; break; + case 97: + var $480=$frame; + var $481=((($480)+(1))|0); + $frame=$481; + __label__ = 93; break; + case 98: + var $483=$2; + _lexerror($483, ((STRING_TABLE.__str24409)|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)); + var $484=$2; + var $485=_lex_do($484); + $1=$485; + __label__ = 256; break; + case 99: + var $487=$ch; + if ((($487)|0) == 40) { + __label__ = 100; break; + } + else if ((($487)|0) == 41 || (($487)|0) == 59 || (($487)|0) == 123 || (($487)|0) == 125 || (($487)|0) == 91 || (($487)|0) == 93 || (($487)|0) == 35) { + __label__ = 106; break; + } + else { + __label__ = 110; break; + } + + case 100: + var $489=$2; + var $490=$ch; + var $491=_lex_tokench($489, $490); + if ($491) { __label__ = 101; break; } else { __label__ = 102; break; } + case 101: + var $493=$2; + var $494=_lex_endtoken($493); + if ($494) { __label__ = 103; break; } else { __label__ = 102; break; } + case 102: + var $496=$2; + var $497=(($496+292)|0); + var $498=(($497)|0); + HEAP32[(($498)>>2)]=143; + $1=143; + __label__ = 256; break; + case 103: + var $500=$2; + var $501=(($500+328)|0); + var $502=(($501)|0); + var $503=HEAP8[($502)]; + var $504=(($503) & 1); + if ($504) { __label__ = 104; break; } else { __label__ = 105; break; } + case 104: + var $506=$ch; + var $507=$2; + var $508=(($507+292)|0); + var $509=(($508)|0); + HEAP32[(($509)>>2)]=$506; + $1=$506; + __label__ = 256; break; + case 105: + var $511=$2; + var $512=(($511+292)|0); + var $513=(($512)|0); + HEAP32[(($513)>>2)]=131; + $1=131; + __label__ = 256; break; + case 106: + var $515=$2; + var $516=$ch; + var $517=_lex_tokench($515, $516); + if ($517) { __label__ = 107; break; } else { __label__ = 108; break; } + case 107: + var $519=$2; + var $520=_lex_endtoken($519); + if ($520) { __label__ = 109; break; } else { __label__ = 108; break; } + case 108: + var $522=$2; + var $523=(($522+292)|0); + var $524=(($523)|0); + HEAP32[(($524)>>2)]=143; + $1=143; + __label__ = 256; break; + case 109: + var $526=$ch; + var $527=$2; + var $528=(($527+292)|0); + var $529=(($528)|0); + HEAP32[(($529)>>2)]=$526; + $1=$526; + __label__ = 256; break; + case 110: + __label__ = 111; break; + case 111: + var $532=$2; + var $533=(($532+328)|0); + var $534=(($533)|0); + var $535=HEAP8[($534)]; + var $536=(($535) & 1); + if ($536) { __label__ = 112; break; } else { __label__ = 135; break; } + case 112: + var $538=$ch; + if ((($538)|0) == 43 || (($538)|0) == 45 || (($538)|0) == 42 || (($538)|0) == 47 || (($538)|0) == 60 || (($538)|0) == 62 || (($538)|0) == 61 || (($538)|0) == 38 || (($538)|0) == 124 || (($538)|0) == 94 || (($538)|0) == 126 || (($538)|0) == 44 || (($538)|0) == 33) { + __label__ = 113; break; + } + else { + __label__ = 117; break; + } + + case 113: + var $540=$2; + var $541=$ch; + var $542=_lex_tokench($540, $541); + if ($542) { __label__ = 114; break; } else { __label__ = 115; break; } + case 114: + var $544=$2; + var $545=_lex_endtoken($544); + if ($545) { __label__ = 116; break; } else { __label__ = 115; break; } + case 115: + var $547=$2; + var $548=(($547+292)|0); + var $549=(($548)|0); + HEAP32[(($549)>>2)]=143; + $1=143; + __label__ = 256; break; + case 116: + var $551=$ch; + var $552=$2; + var $553=(($552+292)|0); + var $554=(($553)|0); + HEAP32[(($554)>>2)]=$551; + $1=$551; + __label__ = 256; break; + case 117: + __label__ = 118; break; + case 118: + var $557=$ch; + var $558=(($557)|0)==46; + if ($558) { __label__ = 119; break; } else { __label__ = 134; break; } + case 119: + var $560=$2; + var $561=$ch; + var $562=_lex_tokench($560, $561); + if ($562) { __label__ = 121; break; } else { __label__ = 120; break; } + case 120: + var $564=$2; + var $565=(($564+292)|0); + var $566=(($565)|0); + HEAP32[(($566)>>2)]=143; + $1=143; + __label__ = 256; break; + case 121: + var $568=$2; + var $569=_lex_getch($568); + $nextch=$569; + var $570=$nextch; + var $571=(($570)|0)!=46; + if ($571) { __label__ = 122; break; } else { __label__ = 125; break; } + case 122: + var $573=$2; + var $574=$nextch; + _lex_ungetch($573, $574); + var $575=$2; + var $576=_lex_endtoken($575); + if ($576) { __label__ = 124; break; } else { __label__ = 123; break; } + case 123: + var $578=$2; + var $579=(($578+292)|0); + var $580=(($579)|0); + HEAP32[(($580)>>2)]=143; + $1=143; + __label__ = 256; break; + case 124: + var $582=$ch; + var $583=$2; + var $584=(($583+292)|0); + var $585=(($584)|0); + HEAP32[(($585)>>2)]=$582; + $1=$582; + __label__ = 256; break; + case 125: + var $587=$2; + var $588=_lex_getch($587); + $nextch=$588; + var $589=$nextch; + var $590=(($589)|0)!=46; + if ($590) { __label__ = 126; break; } else { __label__ = 129; break; } + case 126: + var $592=$2; + var $593=$nextch; + _lex_ungetch($592, $593); + var $594=$2; + var $595=$nextch; + _lex_ungetch($594, $595); + var $596=$2; + var $597=_lex_endtoken($596); + if ($597) { __label__ = 128; break; } else { __label__ = 127; break; } + case 127: + var $599=$2; + var $600=(($599+292)|0); + var $601=(($600)|0); + HEAP32[(($601)>>2)]=143; + $1=143; + __label__ = 256; break; + case 128: + var $603=$ch; + var $604=$2; + var $605=(($604+292)|0); + var $606=(($605)|0); + HEAP32[(($606)>>2)]=$603; + $1=$603; + __label__ = 256; break; + case 129: + var $608=$2; + var $609=$ch; + var $610=_lex_tokench($608, $609); + if ($610) { __label__ = 130; break; } else { __label__ = 132; break; } + case 130: + var $612=$2; + var $613=$ch; + var $614=_lex_tokench($612, $613); + if ($614) { __label__ = 131; break; } else { __label__ = 132; break; } + case 131: + var $616=$2; + var $617=_lex_endtoken($616); + if ($617) { __label__ = 133; break; } else { __label__ = 132; break; } + case 132: + var $619=$2; + var $620=(($619+292)|0); + var $621=(($620)|0); + HEAP32[(($621)>>2)]=143; + $1=143; + __label__ = 256; break; + case 133: + var $623=$2; + var $624=(($623+292)|0); + var $625=(($624)|0); + HEAP32[(($625)>>2)]=133; + $1=133; + __label__ = 256; break; + case 134: + __label__ = 135; break; + case 135: + var $628=$ch; + var $629=(($628)|0)==44; + if ($629) { __label__ = 137; break; } else { __label__ = 136; break; } + case 136: + var $631=$ch; + var $632=(($631)|0)==46; + if ($632) { __label__ = 137; break; } else { __label__ = 141; break; } + case 137: + var $634=$2; + var $635=$ch; + var $636=_lex_tokench($634, $635); + if ($636) { __label__ = 138; break; } else { __label__ = 139; break; } + case 138: + var $638=$2; + var $639=_lex_endtoken($638); + if ($639) { __label__ = 140; break; } else { __label__ = 139; break; } + case 139: + var $641=$2; + var $642=(($641+292)|0); + var $643=(($642)|0); + HEAP32[(($643)>>2)]=143; + $1=143; + __label__ = 256; break; + case 140: + var $645=$2; + var $646=(($645+292)|0); + var $647=(($646)|0); + HEAP32[(($647)>>2)]=131; + $1=131; + __label__ = 256; break; + case 141: + var $649=$ch; + var $650=(($649)|0)==43; + if ($650) { __label__ = 149; break; } else { __label__ = 142; break; } + case 142: + var $652=$ch; + var $653=(($652)|0)==45; + if ($653) { __label__ = 149; break; } else { __label__ = 143; break; } + case 143: + var $655=$ch; + var $656=(($655)|0)==62; + if ($656) { __label__ = 149; break; } else { __label__ = 144; break; } + case 144: + var $658=$ch; + var $659=(($658)|0)==60; + if ($659) { __label__ = 149; break; } else { __label__ = 145; break; } + case 145: + var $661=$ch; + var $662=(($661)|0)==61; + if ($662) { __label__ = 149; break; } else { __label__ = 146; break; } + case 146: + var $664=$ch; + var $665=(($664)|0)==33; + if ($665) { __label__ = 149; break; } else { __label__ = 147; break; } + case 147: + var $667=$ch; + var $668=(($667)|0)==38; + if ($668) { __label__ = 149; break; } else { __label__ = 148; break; } + case 148: + var $670=$ch; + var $671=(($670)|0)==124; + if ($671) { __label__ = 149; break; } else { __label__ = 166; break; } + case 149: + var $673=$2; + var $674=$ch; + var $675=_lex_tokench($673, $674); + if ($675) { __label__ = 151; break; } else { __label__ = 150; break; } + case 150: + var $677=$2; + var $678=(($677+292)|0); + var $679=(($678)|0); + HEAP32[(($679)>>2)]=143; + $1=143; + __label__ = 256; break; + case 151: + var $681=$2; + var $682=_lex_getch($681); + $nextch=$682; + var $683=$nextch; + var $684=$ch; + var $685=(($683)|0)==(($684)|0); + if ($685) { __label__ = 153; break; } else { __label__ = 152; break; } + case 152: + var $687=$nextch; + var $688=(($687)|0)==61; + if ($688) { __label__ = 153; break; } else { __label__ = 156; break; } + case 153: + var $690=$2; + var $691=$nextch; + var $692=_lex_tokench($690, $691); + if ($692) { __label__ = 155; break; } else { __label__ = 154; break; } + case 154: + var $694=$2; + var $695=(($694+292)|0); + var $696=(($695)|0); + HEAP32[(($696)>>2)]=143; + $1=143; + __label__ = 256; break; + case 155: + __label__ = 163; break; + case 156: + var $699=$ch; + var $700=(($699)|0)==45; + if ($700) { __label__ = 157; break; } else { __label__ = 161; break; } + case 157: + var $702=$nextch; + var $703=(($702)|0)==62; + if ($703) { __label__ = 158; break; } else { __label__ = 161; break; } + case 158: + var $705=$2; + var $706=$nextch; + var $707=_lex_tokench($705, $706); + if ($707) { __label__ = 160; break; } else { __label__ = 159; break; } + case 159: + var $709=$2; + var $710=(($709+292)|0); + var $711=(($710)|0); + HEAP32[(($711)>>2)]=143; + $1=143; + __label__ = 256; break; + case 160: + __label__ = 162; break; + case 161: + var $714=$2; + var $715=$nextch; + _lex_ungetch($714, $715); + __label__ = 162; break; + case 162: + __label__ = 163; break; + case 163: + var $718=$2; + var $719=_lex_endtoken($718); + if ($719) { __label__ = 165; break; } else { __label__ = 164; break; } + case 164: + var $721=$2; + var $722=(($721+292)|0); + var $723=(($722)|0); + HEAP32[(($723)>>2)]=143; + $1=143; + __label__ = 256; break; + case 165: + var $725=$2; + var $726=(($725+292)|0); + var $727=(($726)|0); + HEAP32[(($727)>>2)]=131; + $1=131; + __label__ = 256; break; + case 166: + var $729=$ch; + var $730=(($729)|0)==42; + if ($730) { __label__ = 168; break; } else { __label__ = 167; break; } + case 167: + var $732=$ch; + var $733=(($732)|0)==47; + if ($733) { __label__ = 168; break; } else { __label__ = 178; break; } + case 168: + var $735=$2; + var $736=$ch; + var $737=_lex_tokench($735, $736); + if ($737) { __label__ = 170; break; } else { __label__ = 169; break; } + case 169: + var $739=$2; + var $740=(($739+292)|0); + var $741=(($740)|0); + HEAP32[(($741)>>2)]=143; + $1=143; + __label__ = 256; break; + case 170: + var $743=$2; + var $744=_lex_getch($743); + $nextch=$744; + var $745=$nextch; + var $746=(($745)|0)==61; + if ($746) { __label__ = 171; break; } else { __label__ = 174; break; } + case 171: + var $748=$2; + var $749=$nextch; + var $750=_lex_tokench($748, $749); + if ($750) { __label__ = 173; break; } else { __label__ = 172; break; } + case 172: + var $752=$2; + var $753=(($752+292)|0); + var $754=(($753)|0); + HEAP32[(($754)>>2)]=143; + $1=143; + __label__ = 256; break; + case 173: + __label__ = 175; break; + case 174: + var $757=$2; + var $758=$nextch; + _lex_ungetch($757, $758); + __label__ = 175; break; + case 175: + var $760=$2; + var $761=_lex_endtoken($760); + if ($761) { __label__ = 177; break; } else { __label__ = 176; break; } + case 176: + var $763=$2; + var $764=(($763+292)|0); + var $765=(($764)|0); + HEAP32[(($765)>>2)]=143; + $1=143; + __label__ = 256; break; + case 177: + var $767=$2; + var $768=(($767+292)|0); + var $769=(($768)|0); + HEAP32[(($769)>>2)]=131; + $1=131; + __label__ = 256; break; + case 178: + var $771=$ch; + var $772=_isident_start($771); + if ($772) { __label__ = 179; break; } else { __label__ = 222; break; } + case 179: + var $774=$2; + var $775=$ch; + var $776=_lex_tokench($774, $775); + if ($776) { __label__ = 181; break; } else { __label__ = 180; break; } + case 180: + var $778=$2; + var $779=(($778+292)|0); + var $780=(($779)|0); + HEAP32[(($780)>>2)]=143; + $1=143; + __label__ = 256; break; + case 181: + var $782=$2; + var $783=_lex_finish_ident($782); + if ($783) { __label__ = 183; break; } else { __label__ = 182; break; } + case 182: + var $785=$2; + var $786=(($785+292)|0); + var $787=(($786)|0); + HEAP32[(($787)>>2)]=142; + $1=142; + __label__ = 256; break; + case 183: + var $789=$2; + var $790=_lex_endtoken($789); + if ($790) { __label__ = 185; break; } else { __label__ = 184; break; } + case 184: + var $792=$2; + var $793=(($792+292)|0); + var $794=(($793)|0); + HEAP32[(($794)>>2)]=143; + $1=143; + __label__ = 256; break; + case 185: + var $796=$2; + var $797=(($796+292)|0); + var $798=(($797)|0); + HEAP32[(($798)>>2)]=129; + var $799=$2; + var $800=(($799+292)|0); + var $801=(($800+4)|0); + var $802=HEAP32[(($801)>>2)]; + $v3=$802; + var $803=$v3; + var $804=_strcmp($803, ((STRING_TABLE.__str25410)|0)); + var $805=(($804)|0)!=0; + if ($805) { __label__ = 187; break; } else { __label__ = 186; break; } + case 186: + var $807=$2; + var $808=(($807+292)|0); + var $809=(($808)|0); + HEAP32[(($809)>>2)]=130; + var $810=$2; + var $811=(($810+292)|0); + var $812=(($811+16)|0); + var $813=$812; + HEAP32[(($813)>>2)]=0; + __label__ = 221; break; + case 187: + var $815=$v3; + var $816=_strcmp($815, ((STRING_TABLE.__str26411)|0)); + var $817=(($816)|0)!=0; + if ($817) { __label__ = 189; break; } else { __label__ = 188; break; } + case 188: + var $819=$2; + var $820=(($819+292)|0); + var $821=(($820)|0); + HEAP32[(($821)>>2)]=130; + var $822=$2; + var $823=(($822+292)|0); + var $824=(($823+16)|0); + var $825=$824; + HEAP32[(($825)>>2)]=8; + __label__ = 220; break; + case 189: + var $827=$v3; + var $828=_strcmp($827, ((STRING_TABLE.__str27412)|0)); + var $829=(($828)|0)!=0; + if ($829) { __label__ = 191; break; } else { __label__ = 190; break; } + case 190: + var $831=$2; + var $832=(($831+292)|0); + var $833=(($832)|0); + HEAP32[(($833)>>2)]=130; + var $834=$2; + var $835=(($834+292)|0); + var $836=(($835+16)|0); + var $837=$836; + HEAP32[(($837)>>2)]=2; + __label__ = 219; break; + case 191: + var $839=$v3; + var $840=_strcmp($839, ((STRING_TABLE.__str28413)|0)); + var $841=(($840)|0)!=0; + if ($841) { __label__ = 193; break; } else { __label__ = 192; break; } + case 192: + var $843=$2; + var $844=(($843+292)|0); + var $845=(($844)|0); + HEAP32[(($845)>>2)]=130; + var $846=$2; + var $847=(($846+292)|0); + var $848=(($847+16)|0); + var $849=$848; + HEAP32[(($849)>>2)]=1; + __label__ = 218; break; + case 193: + var $851=$v3; + var $852=_strcmp($851, ((STRING_TABLE.__str29414)|0)); + var $853=(($852)|0)!=0; + if ($853) { __label__ = 195; break; } else { __label__ = 194; break; } + case 194: + var $855=$2; + var $856=(($855+292)|0); + var $857=(($856)|0); + HEAP32[(($857)>>2)]=130; + var $858=$2; + var $859=(($858+292)|0); + var $860=(($859+16)|0); + var $861=$860; + HEAP32[(($861)>>2)]=4; + __label__ = 217; break; + case 195: + var $863=$v3; + var $864=_strcmp($863, ((STRING_TABLE.__str30415)|0)); + var $865=(($864)|0)!=0; + if ($865) { __label__ = 197; break; } else { __label__ = 196; break; } + case 196: + var $867=$2; + var $868=(($867+292)|0); + var $869=(($868)|0); + HEAP32[(($869)>>2)]=130; + var $870=$2; + var $871=(($870+292)|0); + var $872=(($871+16)|0); + var $873=$872; + HEAP32[(($873)>>2)]=3; + __label__ = 216; break; + case 197: + var $875=$v3; + var $876=_strcmp($875, ((STRING_TABLE.__str31416)|0)); + var $877=(($876)|0)!=0; + if ($877) { __label__ = 198; break; } else { __label__ = 205; break; } + case 198: + var $879=$v3; + var $880=_strcmp($879, ((STRING_TABLE.__str32417)|0)); + var $881=(($880)|0)!=0; + if ($881) { __label__ = 199; break; } else { __label__ = 205; break; } + case 199: + var $883=$v3; + var $884=_strcmp($883, ((STRING_TABLE.__str33418)|0)); + var $885=(($884)|0)!=0; + if ($885) { __label__ = 200; break; } else { __label__ = 205; break; } + case 200: + var $887=$v3; + var $888=_strcmp($887, ((STRING_TABLE.__str34419)|0)); + var $889=(($888)|0)!=0; + if ($889) { __label__ = 201; break; } else { __label__ = 205; break; } + case 201: + var $891=$v3; + var $892=_strcmp($891, ((STRING_TABLE.__str35420)|0)); + var $893=(($892)|0)!=0; + if ($893) { __label__ = 202; break; } else { __label__ = 205; break; } + case 202: + var $895=$v3; + var $896=_strcmp($895, ((STRING_TABLE.__str36421)|0)); + var $897=(($896)|0)!=0; + if ($897) { __label__ = 203; break; } else { __label__ = 205; break; } + case 203: + var $899=$v3; + var $900=_strcmp($899, ((STRING_TABLE.__str37422)|0)); + var $901=(($900)|0)!=0; + if ($901) { __label__ = 204; break; } else { __label__ = 205; break; } + case 204: + var $903=$v3; + var $904=_strcmp($903, ((STRING_TABLE.__str38423)|0)); + var $905=(($904)|0)!=0; + if ($905) { __label__ = 206; break; } else { __label__ = 205; break; } + case 205: + var $907=$2; + var $908=(($907+292)|0); + var $909=(($908)|0); + HEAP32[(($909)>>2)]=132; + __label__ = 215; break; + case 206: + var $911=HEAP32[((_opts_standard)>>2)]; + var $912=(($911)|0)!=0; + if ($912) { __label__ = 207; break; } else { __label__ = 214; break; } + case 207: + var $914=$v3; + var $915=_strcmp($914, ((STRING_TABLE.__str39424)|0)); + var $916=(($915)|0)!=0; + if ($916) { __label__ = 208; break; } else { __label__ = 212; break; } + case 208: + var $918=$v3; + var $919=_strcmp($918, ((STRING_TABLE.__str40425)|0)); + var $920=(($919)|0)!=0; + if ($920) { __label__ = 209; break; } else { __label__ = 212; break; } + case 209: + var $922=$v3; + var $923=_strcmp($922, ((STRING_TABLE.__str41426)|0)); + var $924=(($923)|0)!=0; + if ($924) { __label__ = 210; break; } else { __label__ = 212; break; } + case 210: + var $926=$v3; + var $927=_strcmp($926, ((STRING_TABLE.__str42427)|0)); + var $928=(($927)|0)!=0; + if ($928) { __label__ = 211; break; } else { __label__ = 212; break; } + case 211: + var $930=$v3; + var $931=_strcmp($930, ((STRING_TABLE.__str43428)|0)); + var $932=(($931)|0)!=0; + if ($932) { __label__ = 213; break; } else { __label__ = 212; break; } + case 212: + var $934=$2; + var $935=(($934+292)|0); + var $936=(($935)|0); + HEAP32[(($936)>>2)]=132; + __label__ = 213; break; + case 213: + __label__ = 214; break; + case 214: + __label__ = 215; break; + case 215: + __label__ = 216; break; + case 216: + __label__ = 217; break; + case 217: + __label__ = 218; break; + case 218: + __label__ = 219; break; + case 219: + __label__ = 220; break; + case 220: + __label__ = 221; break; + case 221: + var $946=$2; + var $947=(($946+292)|0); + var $948=(($947)|0); + var $949=HEAP32[(($948)>>2)]; + $1=$949; + __label__ = 256; break; + case 222: + var $951=$ch; + var $952=(($951)|0)==34; + if ($952) { __label__ = 223; break; } else { __label__ = 239; break; } + case 223: + var $954=$2; + var $955=(($954+328)|0); + var $956=(($955+1)|0); + HEAP8[($956)]=1; + var $957=$2; + var $958=(($957+328)|0); + var $959=(($958+2)|0); + var $960=HEAP8[($959)]; + var $961=(($960) & 1); + if ($961) { __label__ = 224; break; } else { __label__ = 226; break; } + case 224: + var $963=$2; + var $964=$ch; + var $965=_lex_tokench($963, $964); + if ($965) { __label__ = 226; break; } else { __label__ = 225; break; } + case 225: + $1=143; + __label__ = 256; break; + case 226: + var $968=$2; + var $969=_lex_finish_string($968, 34); + var $970=$2; + var $971=(($970+292)|0); + var $972=(($971)|0); + HEAP32[(($972)>>2)]=$969; + var $973=$2; + var $974=(($973+328)|0); + var $975=(($974+2)|0); + var $976=HEAP8[($975)]; + var $977=(($976) & 1); + if ($977) { __label__ = 227; break; } else { __label__ = 229; break; } + case 227: + var $979=$2; + var $980=$ch; + var $981=_lex_tokench($979, $980); + if ($981) { __label__ = 229; break; } else { __label__ = 228; break; } + case 228: + $1=143; + __label__ = 256; break; + case 229: + __label__ = 230; break; + case 230: + var $985=$2; + var $986=(($985+328)|0); + var $987=(($986+2)|0); + var $988=HEAP8[($987)]; + var $989=(($988) & 1); + if ($989) { var $997 = 0;__label__ = 232; break; } else { __label__ = 231; break; } + case 231: + var $991=$2; + var $992=(($991+292)|0); + var $993=(($992)|0); + var $994=HEAP32[(($993)>>2)]; + var $995=(($994)|0)==134; + var $997 = $995;__label__ = 232; break; + case 232: + var $997; + if ($997) { __label__ = 233; break; } else { __label__ = 236; break; } + case 233: + var $999=$2; + var $1000=_lex_skipwhite($999); + $ch=$1000; + var $1001=$ch; + var $1002=(($1001)|0)!=34; + if ($1002) { __label__ = 234; break; } else { __label__ = 235; break; } + case 234: + var $1004=$2; + var $1005=$ch; + _lex_ungetch($1004, $1005); + __label__ = 236; break; + case 235: + var $1007=$2; + var $1008=_lex_finish_string($1007, 34); + var $1009=$2; + var $1010=(($1009+292)|0); + var $1011=(($1010)|0); + HEAP32[(($1011)>>2)]=$1008; + __label__ = 230; break; + case 236: + var $1013=$2; + var $1014=(($1013+328)|0); + var $1015=(($1014+1)|0); + HEAP8[($1015)]=0; + var $1016=$2; + var $1017=_lex_endtoken($1016); + if ($1017) { __label__ = 238; break; } else { __label__ = 237; break; } + case 237: + var $1019=$2; + var $1020=(($1019+292)|0); + var $1021=(($1020)|0); + HEAP32[(($1021)>>2)]=143; + $1=143; + __label__ = 256; break; + case 238: + var $1023=$2; + var $1024=(($1023+292)|0); + var $1025=(($1024)|0); + var $1026=HEAP32[(($1025)>>2)]; + $1=$1026; + __label__ = 256; break; + case 239: + var $1028=$ch; + var $1029=(($1028)|0)==39; + if ($1029) { __label__ = 240; break; } else { __label__ = 251; break; } + case 240: + var $1031=$2; + var $1032=(($1031+328)|0); + var $1033=(($1032+2)|0); + var $1034=HEAP8[($1033)]; + var $1035=(($1034) & 1); + if ($1035) { __label__ = 241; break; } else { __label__ = 243; break; } + case 241: + var $1037=$2; + var $1038=$ch; + var $1039=_lex_tokench($1037, $1038); + if ($1039) { __label__ = 243; break; } else { __label__ = 242; break; } + case 242: + $1=143; + __label__ = 256; break; + case 243: + var $1042=$2; + var $1043=_lex_finish_string($1042, 39); + var $1044=$2; + var $1045=(($1044+292)|0); + var $1046=(($1045)|0); + HEAP32[(($1046)>>2)]=$1043; + var $1047=$2; + var $1048=(($1047+328)|0); + var $1049=(($1048+2)|0); + var $1050=HEAP8[($1049)]; + var $1051=(($1050) & 1); + if ($1051) { __label__ = 244; break; } else { __label__ = 246; break; } + case 244: + var $1053=$2; + var $1054=$ch; + var $1055=_lex_tokench($1053, $1054); + if ($1055) { __label__ = 246; break; } else { __label__ = 245; break; } + case 245: + $1=143; + __label__ = 256; break; + case 246: + var $1058=$2; + var $1059=_lex_endtoken($1058); + if ($1059) { __label__ = 248; break; } else { __label__ = 247; break; } + case 247: + var $1061=$2; + var $1062=(($1061+292)|0); + var $1063=(($1062)|0); + HEAP32[(($1063)>>2)]=143; + $1=143; + __label__ = 256; break; + case 248: + var $1065=$2; + var $1066=(($1065+292)|0); + var $1067=(($1066+4)|0); + var $1068=HEAP32[(($1067)>>2)]; + var $1069=$2; + var $1070=(($1069+292)|0); + var $1071=(($1070+16)|0); + var $1072=$1071; + var $1073=(($1072)|0); + var $1074=$2; + var $1075=(($1074+292)|0); + var $1076=(($1075+16)|0); + var $1077=$1076; + var $1078=(($1077+4)|0); + var $1079=$2; + var $1080=(($1079+292)|0); + var $1081=(($1080+16)|0); + var $1082=$1081; + var $1083=(($1082+8)|0); + var $1084=_sscanf($1068, ((STRING_TABLE.__str44429)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1073,HEAP32[(((tempInt)+(4))>>2)]=$1078,HEAP32[(((tempInt)+(8))>>2)]=$1083,tempInt)); + var $1085=(($1084)|0)==3; + if ($1085) { __label__ = 249; break; } else { __label__ = 250; break; } + case 249: + var $1087=$2; + var $1088=(($1087+292)|0); + var $1089=(($1088)|0); + HEAP32[(($1089)>>2)]=136; + __label__ = 250; break; + case 250: + var $1091=$2; + var $1092=(($1091+292)|0); + var $1093=(($1092)|0); + var $1094=HEAP32[(($1093)>>2)]; + $1=$1094; + __label__ = 256; break; + case 251: + var $1096=$ch; + var $1097=_isdigit($1096); + var $1098=(($1097)|0)!=0; + if ($1098) { __label__ = 252; break; } else { __label__ = 255; break; } + case 252: + var $1100=$2; + var $1101=$ch; + var $1102=_lex_finish_digit($1100, $1101); + var $1103=$2; + var $1104=(($1103+292)|0); + var $1105=(($1104)|0); + HEAP32[(($1105)>>2)]=$1102; + var $1106=$2; + var $1107=_lex_endtoken($1106); + if ($1107) { __label__ = 254; break; } else { __label__ = 253; break; } + case 253: + var $1109=$2; + var $1110=(($1109+292)|0); + var $1111=(($1110)|0); + HEAP32[(($1111)>>2)]=143; + $1=143; + __label__ = 256; break; + case 254: + var $1113=$2; + var $1114=(($1113+292)|0); + var $1115=(($1114)|0); + var $1116=HEAP32[(($1115)>>2)]; + $1=$1116; + __label__ = 256; break; + case 255: + var $1118=$2; + _lexerror($1118, ((STRING_TABLE.__str45430)|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)); + var $1119=$2; + var $1120=(($1119+292)|0); + var $1121=(($1120)|0); + HEAP32[(($1121)>>2)]=142; + $1=142; + __label__ = 256; break; + case 256: + var $1123=$1; + STACKTOP = __stackBase__; + return $1123; + default: assert(0, "bad label: " + __label__); + } +} +_lex_do["X"]=1; + +function _lex_token_new($lex) { + ; + var __label__; + + var $1; + $1=$lex; + var $2=$1; + var $3=(($2+292)|0); + var $4=(($3+8)|0); + HEAP32[(($4)>>2)]=0; + var $5=$1; + var $6=(($5+292)|0); + var $7=(($6+16)|0); + var $8=$7; + HEAP32[(($8)>>2)]=0; + var $9=$1; + var $10=(($9+24)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=$1; + var $13=(($12+292)|0); + var $14=(($13+28)|0); + var $15=(($14+4)|0); + HEAP32[(($15)>>2)]=$11; + var $16=$1; + var $17=(($16+16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+292)|0); + var $21=(($20+28)|0); + var $22=(($21)|0); + HEAP32[(($22)>>2)]=$18; + ; + return; +} + + +function _lex_skipwhite($lex) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ch; + var $haswhite; + $2=$lex; + $ch=0; + $haswhite=0; + __label__ = 3; break; + case 3: + var $4=$2; + var $5=_lex_getch($4); + $ch=$5; + __label__ = 4; break; + case 4: + var $7=$ch; + var $8=(($7)|0)!=-1; + if ($8) { __label__ = 5; break; } else { var $14 = 0;__label__ = 6; break; } + case 5: + var $10=$ch; + var $11=_isspace($10); + var $12=(($11)|0)!=0; + var $14 = $12;__label__ = 6; break; + case 6: + var $14; + if ($14) { __label__ = 7; break; } else { __label__ = 18; break; } + case 7: + var $16=$2; + var $17=(($16+328)|0); + var $18=(($17+2)|0); + var $19=HEAP8[($18)]; + var $20=(($19) & 1); + if ($20) { __label__ = 8; break; } else { __label__ = 17; break; } + case 8: + var $22=$ch; + var $23=(($22)|0)==10; + if ($23) { __label__ = 9; break; } else { __label__ = 14; break; } + case 9: + var $25=$haswhite; + var $26=(($25) & 1); + if ($26) { __label__ = 10; break; } else { __label__ = 13; break; } + case 10: + var $28=$2; + var $29=$ch; + _lex_ungetch($28, $29); + var $30=$2; + var $31=_lex_endtoken($30); + if ($31) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $1=143; + __label__ = 71; break; + case 12: + $1=139; + __label__ = 71; break; + case 13: + $1=140; + __label__ = 71; break; + case 14: + $haswhite=1; + var $36=$2; + var $37=$ch; + var $38=_lex_tokench($36, $37); + if ($38) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=143; + __label__ = 71; break; + case 16: + __label__ = 17; break; + case 17: + var $42=$2; + var $43=_lex_getch($42); + $ch=$43; + __label__ = 4; break; + case 18: + var $45=$ch; + var $46=(($45)|0)==47; + if ($46) { __label__ = 19; break; } else { __label__ = 62; break; } + case 19: + var $48=$2; + var $49=_lex_getch($48); + $ch=$49; + var $50=$ch; + var $51=(($50)|0)==47; + if ($51) { __label__ = 20; break; } else { __label__ = 38; break; } + case 20: + var $53=$2; + var $54=_lex_getch($53); + $ch=$54; + var $55=$2; + var $56=(($55+328)|0); + var $57=(($56+2)|0); + var $58=HEAP8[($57)]; + var $59=(($58) & 1); + if ($59) { __label__ = 21; break; } else { __label__ = 25; break; } + case 21: + $haswhite=1; + var $61=$2; + var $62=_lex_tokench($61, 47); + if ($62) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $64=$2; + var $65=_lex_tokench($64, 47); + if ($65) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + $1=143; + __label__ = 71; break; + case 24: + __label__ = 25; break; + case 25: + __label__ = 26; break; + case 26: + var $70=$ch; + var $71=(($70)|0)!=-1; + if ($71) { __label__ = 27; break; } else { var $76 = 0;__label__ = 28; break; } + case 27: + var $73=$ch; + var $74=(($73)|0)!=10; + var $76 = $74;__label__ = 28; break; + case 28: + var $76; + if ($76) { __label__ = 29; break; } else { __label__ = 33; break; } + case 29: + var $78=$2; + var $79=(($78+328)|0); + var $80=(($79+2)|0); + var $81=HEAP8[($80)]; + var $82=(($81) & 1); + if ($82) { __label__ = 30; break; } else { __label__ = 32; break; } + case 30: + var $84=$2; + var $85=$ch; + var $86=_lex_tokench($84, $85); + if ($86) { __label__ = 32; break; } else { __label__ = 31; break; } + case 31: + $1=143; + __label__ = 71; break; + case 32: + var $89=$2; + var $90=_lex_getch($89); + $ch=$90; + __label__ = 26; break; + case 33: + var $92=$2; + var $93=(($92+328)|0); + var $94=(($93+2)|0); + var $95=HEAP8[($94)]; + var $96=(($95) & 1); + if ($96) { __label__ = 34; break; } else { __label__ = 37; break; } + case 34: + var $98=$2; + _lex_ungetch($98, 10); + var $99=$2; + var $100=_lex_endtoken($99); + if ($100) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + $1=143; + __label__ = 71; break; + case 36: + $1=139; + __label__ = 71; break; + case 37: + __label__ = 63; break; + case 38: + var $105=$ch; + var $106=(($105)|0)==42; + if ($106) { __label__ = 39; break; } else { __label__ = 61; break; } + case 39: + var $108=$2; + var $109=(($108+328)|0); + var $110=(($109+2)|0); + var $111=HEAP8[($110)]; + var $112=(($111) & 1); + if ($112) { __label__ = 40; break; } else { __label__ = 44; break; } + case 40: + $haswhite=1; + var $114=$2; + var $115=_lex_tokench($114, 47); + if ($115) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + var $117=$2; + var $118=_lex_tokench($117, 42); + if ($118) { __label__ = 43; break; } else { __label__ = 42; break; } + case 42: + $1=143; + __label__ = 71; break; + case 43: + __label__ = 44; break; + case 44: + __label__ = 45; break; + case 45: + var $123=$ch; + var $124=(($123)|0)!=-1; + if ($124) { __label__ = 46; break; } else { __label__ = 60; break; } + case 46: + var $126=$2; + var $127=_lex_getch($126); + $ch=$127; + var $128=$ch; + var $129=(($128)|0)==42; + if ($129) { __label__ = 47; break; } else { __label__ = 55; break; } + case 47: + var $131=$2; + var $132=_lex_getch($131); + $ch=$132; + var $133=$ch; + var $134=(($133)|0)==47; + if ($134) { __label__ = 48; break; } else { __label__ = 54; break; } + case 48: + var $136=$2; + var $137=(($136+328)|0); + var $138=(($137+2)|0); + var $139=HEAP8[($138)]; + var $140=(($139) & 1); + if ($140) { __label__ = 49; break; } else { __label__ = 53; break; } + case 49: + var $142=$2; + var $143=_lex_tokench($142, 42); + if ($143) { __label__ = 50; break; } else { __label__ = 51; break; } + case 50: + var $145=$2; + var $146=_lex_tokench($145, 47); + if ($146) { __label__ = 52; break; } else { __label__ = 51; break; } + case 51: + $1=143; + __label__ = 71; break; + case 52: + __label__ = 53; break; + case 53: + __label__ = 60; break; + case 54: + __label__ = 55; break; + case 55: + var $152=$2; + var $153=(($152+328)|0); + var $154=(($153+2)|0); + var $155=HEAP8[($154)]; + var $156=(($155) & 1); + if ($156) { __label__ = 56; break; } else { __label__ = 59; break; } + case 56: + var $158=$2; + var $159=$ch; + var $160=_lex_tokench($158, $159); + if ($160) { __label__ = 58; break; } else { __label__ = 57; break; } + case 57: + $1=143; + __label__ = 71; break; + case 58: + __label__ = 59; break; + case 59: + __label__ = 45; break; + case 60: + $ch=32; + __label__ = 63; break; + case 61: + var $166=$2; + var $167=$ch; + _lex_ungetch($166, $167); + $ch=47; + __label__ = 66; break; + case 62: + __label__ = 63; break; + case 63: + var $170=$ch; + var $171=(($170)|0)!=-1; + if ($171) { __label__ = 64; break; } else { var $177 = 0;__label__ = 65; break; } + case 64: + var $173=$ch; + var $174=_isspace($173); + var $175=(($174)|0)!=0; + var $177 = $175;__label__ = 65; break; + case 65: + var $177; + if ($177) { __label__ = 3; break; } else { __label__ = 66; break; } + case 66: + var $179=$haswhite; + var $180=(($179) & 1); + if ($180) { __label__ = 67; break; } else { __label__ = 70; break; } + case 67: + var $182=$2; + var $183=_lex_endtoken($182); + if ($183) { __label__ = 69; break; } else { __label__ = 68; break; } + case 68: + $1=143; + __label__ = 71; break; + case 69: + var $186=$2; + var $187=$ch; + _lex_ungetch($186, $187); + $1=139; + __label__ = 71; break; + case 70: + var $189=$ch; + $1=$189; + __label__ = 71; break; + case 71: + var $191=$1; + ; + return $191; + default: assert(0, "bad label: " + __label__); + } +} +_lex_skipwhite["X"]=1; + +function _lex_getch($lex) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ch; + $2=$lex; + var $3=$2; + var $4=(($3+284)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $8=$2; + var $9=(($8+284)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=((($10)-(1))|0); + HEAP32[(($9)>>2)]=$11; + var $12=$2; + var $13=(($12+284)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$2; + var $16=(($15+28)|0); + var $17=(($16+$14)|0); + var $18=HEAP8[($17)]; + var $19=(($18 << 24) >> 24); + var $20=(($19)|0)==10; + if ($20) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $22=$2; + var $23=(($22+20)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=((($24)+(1))|0); + HEAP32[(($23)>>2)]=$25; + __label__ = 5; break; + case 5: + var $27=$2; + var $28=(($27+284)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=$2; + var $31=(($30+28)|0); + var $32=(($31+$29)|0); + var $33=HEAP8[($32)]; + var $34=(($33 << 24) >> 24); + $1=$34; + __label__ = 18; break; + case 6: + var $36=$2; + var $37=_lex_fgetc($36); + $ch=$37; + var $38=$ch; + var $39=(($38)|0)==10; + if ($39) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $41=$2; + var $42=(($41+20)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43)+(1))|0); + HEAP32[(($42)>>2)]=$44; + __label__ = 17; break; + case 8: + var $46=$ch; + var $47=(($46)|0)==63; + if ($47) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $49=$2; + var $50=$ch; + var $51=_lex_try_trigraph($49, $50); + $1=$51; + __label__ = 18; break; + case 10: + var $53=$2; + var $54=(($53+328)|0); + var $55=(($54+1)|0); + var $56=HEAP8[($55)]; + var $57=(($56) & 1); + if ($57) { __label__ = 15; break; } else { __label__ = 11; break; } + case 11: + var $59=$ch; + var $60=(($59)|0)==60; + if ($60) { __label__ = 14; break; } else { __label__ = 12; break; } + case 12: + var $62=$ch; + var $63=(($62)|0)==58; + if ($63) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + var $65=$ch; + var $66=(($65)|0)==37; + if ($66) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + var $68=$2; + var $69=$ch; + var $70=_lex_try_digraph($68, $69); + $1=$70; + __label__ = 18; break; + case 15: + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + var $74=$ch; + $1=$74; + __label__ = 18; break; + case 18: + var $76=$1; + ; + return $76; + default: assert(0, "bad label: " + __label__); + } +} +_lex_getch["X"]=1; + +function _isident_start($ch) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$ch; + var $2=$1; + var $3=_isalpha($2); + var $4=(($3)|0)!=0; + if ($4) { var $9 = 1;__label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $6=$1; + var $7=(($6)|0)==95; + var $9 = $7;__label__ = 4; break; + case 4: + var $9; + ; + return $9; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_tokench($lex, $ch) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$lex; + $3=$ch; + var $4=$2; + var $5=(($4+292)|0); + var $6=$3; + var $7=(($6) & 255); + var $8=_token_value_add($5, $7); + if ($8) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $10=$2; + _lexerror($10, ((STRING_TABLE.__str16401)|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)); + $1=0; + __label__ = 5; break; + case 4: + $1=1; + __label__ = 5; break; + case 5: + var $13=$1; + STACKTOP = __stackBase__; + return $13; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_finish_ident($lex) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ch; + $2=$lex; + var $3=$2; + var $4=_lex_getch($3); + $ch=$4; + __label__ = 3; break; + case 3: + var $6=$ch; + var $7=(($6)|0)!=-1; + if ($7) { __label__ = 4; break; } else { var $12 = 0;__label__ = 5; break; } + case 4: + var $9=$ch; + var $10=_isident($9); + var $12 = $10;__label__ = 5; break; + case 5: + var $12; + if ($12) { __label__ = 6; break; } else { __label__ = 9; break; } + case 6: + var $14=$2; + var $15=$ch; + var $16=_lex_tokench($14, $15); + if ($16) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $18=$2; + var $19=(($18+292)|0); + var $20=(($19)|0); + HEAP32[(($20)>>2)]=143; + $1=1; + __label__ = 10; break; + case 8: + var $22=$2; + var $23=_lex_getch($22); + $ch=$23; + __label__ = 3; break; + case 9: + var $25=$2; + var $26=$ch; + _lex_ungetch($25, $26); + $1=1; + __label__ = 10; break; + case 10: + var $28=$1; + ; + return $28; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_endtoken($lex) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$lex; + var $3=$2; + var $4=(($3+292)|0); + var $5=_token_value_add($4, 0); + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $7=$2; + _lexerror($7, ((STRING_TABLE.__str16401)|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)); + $1=0; + __label__ = 5; break; + case 4: + var $9=$2; + var $10=(($9+292)|0); + var $11=(($10+8)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=((($12)-(1))|0); + HEAP32[(($11)>>2)]=$13; + $1=1; + __label__ = 5; break; + case 5: + var $15=$1; + STACKTOP = __stackBase__; + return $15; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_finish_frames($lex) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $rc; + var $m=__stackBase__; + $2=$lex; + __label__ = 3; break; + case 3: + var $4=$2; + var $5=_lex_parse_frame($4); + $rc=$5; + var $6=$rc; + var $7=(($6)|0) > 0; + if ($7) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $1=1; + __label__ = 21; break; + case 5: + var $10=$rc; + var $11=(($10)|0) < 0; + if ($11) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + $1=0; + __label__ = 21; break; + case 7: + $i=0; + __label__ = 8; break; + case 8: + var $15=$i; + var $16=$2; + var $17=(($16+340)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($15)>>>0) < (($18)>>>0); + if ($19) { __label__ = 9; break; } else { __label__ = 15; break; } + case 9: + var $21=$2; + var $22=(($21+292)|0); + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$i; + var $26=$2; + var $27=(($26+336)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28+($25<<3))|0); + var $30=(($29)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=_strcmp($24, $31); + var $33=(($32)|0)!=0; + if ($33) { __label__ = 13; break; } else { __label__ = 10; break; } + case 10: + var $35=$2; + var $36=(($35+332)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=((($37)+(1))|0); + HEAP32[(($36)>>2)]=$38; + var $39=$i; + var $40=$2; + var $41=(($40+336)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=(($42+($39<<3))|0); + var $44=(($43+4)|0); + HEAP32[(($44)>>2)]=$37; + var $45=$2; + var $46=$2; + var $47=(($46+292)|0); + var $48=(($47+4)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=_lexwarn($45, 13, ((STRING_TABLE.__str51436)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$49,tempInt)); + if ($50) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + $1=0; + __label__ = 21; break; + case 12: + __label__ = 15; break; + case 13: + __label__ = 14; break; + case 14: + var $55=$i; + var $56=((($55)+(1))|0); + $i=$56; + __label__ = 8; break; + case 15: + var $58=$i; + var $59=$2; + var $60=(($59+340)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($58)>>>0) < (($61)>>>0); + if ($62) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + __label__ = 20; break; + case 17: + var $65=$2; + var $66=(($65+332)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=((($67)+(1))|0); + HEAP32[(($66)>>2)]=$68; + var $69=(($m+4)|0); + HEAP32[(($69)>>2)]=$67; + var $70=$2; + var $71=(($70+292)|0); + var $72=(($71+4)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=(($m)|0); + HEAP32[(($74)>>2)]=$73; + var $75=$2; + var $76=(($75+292)|0); + var $77=(($76+4)|0); + HEAP32[(($77)>>2)]=0; + var $78=$2; + var $79=(($78+292)|0); + var $80=(($79+8)|0); + HEAP32[(($80)>>2)]=0; + var $81=$2; + var $82=(($81+292)|0); + var $83=(($82+12)|0); + HEAP32[(($83)>>2)]=0; + var $84=$2; + var $85=(($m)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=(($m+4)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=_lex_file_frames_add($84, $86, $88); + if ($89) { __label__ = 19; break; } else { __label__ = 18; break; } + case 18: + var $91=$2; + _lexerror($91, ((STRING_TABLE.__str16401)|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)); + $1=0; + __label__ = 21; break; + case 19: + __label__ = 20; break; + case 20: + if (1) { __label__ = 3; break; } else { __label__ = 21; break; } + case 21: + var $95=$1; + STACKTOP = __stackBase__; + return $95; + default: assert(0, "bad label: " + __label__); + } +} +_lex_finish_frames["X"]=1; + +function _isxdigit_only($ch) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$ch; + var $2=$1; + var $3=(($2)|0) >= 97; + if ($3) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $5=$1; + var $6=(($5)|0) <= 102; + if ($6) { var $16 = 1;__label__ = 7; break; } else { __label__ = 4; break; } + case 4: + var $8=$1; + var $9=(($8)|0) >= 65; + if ($9) { __label__ = 5; break; } else { var $14 = 0;__label__ = 6; break; } + case 5: + var $11=$1; + var $12=(($11)|0) <= 70; + var $14 = $12;__label__ = 6; break; + case 6: + var $14; + var $16 = $14;__label__ = 7; break; + case 7: + var $16; + ; + return $16; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_ungetch($lex, $ch) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$lex; + $2=$ch; + var $3=$2; + var $4=(($3) & 255); + var $5=$1; + var $6=(($5+284)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=((($7)+(1))|0); + HEAP32[(($6)>>2)]=$8; + var $9=$1; + var $10=(($9+28)|0); + var $11=(($10+$7)|0); + HEAP8[($11)]=$4; + var $12=$2; + var $13=(($12)|0)==10; + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$1; + var $16=(($15+20)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=((($17)-(1))|0); + HEAP32[(($16)>>2)]=$18; + __label__ = 4; break; + case 4: + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_finish_digit($lex, $lastch) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $ishex; + var $ch; + $2=$lex; + $3=$lastch; + $ishex=0; + var $4=$3; + $ch=$4; + var $5=$2; + var $6=(($5+292)|0); + var $7=(($6)|0); + HEAP32[(($7)>>2)]=137; + var $8=$2; + var $9=$ch; + var $10=_lex_tokench($8, $9); + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $12=$2; + var $13=(($12+292)|0); + var $14=(($13)|0); + HEAP32[(($14)>>2)]=143; + $1=143; + __label__ = 46; break; + case 4: + var $16=$2; + var $17=_lex_getch($16); + $ch=$17; + var $18=$ch; + var $19=(($18)|0)!=46; + if ($19) { __label__ = 5; break; } else { __label__ = 12; break; } + case 5: + var $21=$ch; + var $22=_isdigit($21); + var $23=(($22)|0)!=0; + if ($23) { __label__ = 12; break; } else { __label__ = 6; break; } + case 6: + var $25=$3; + var $26=(($25)|0)!=48; + if ($26) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $28=$ch; + var $29=(($28)|0)!=120; + if ($29) { __label__ = 8; break; } else { __label__ = 11; break; } + case 8: + var $31=$2; + var $32=$ch; + _lex_ungetch($31, $32); + var $33=$2; + var $34=_lex_endtoken($33); + if ($34) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $36=$2; + var $37=(($36+292)|0); + var $38=(($37)|0); + HEAP32[(($38)>>2)]=143; + $1=143; + __label__ = 46; break; + case 10: + var $40=$3; + var $41=((($40)-(48))|0); + var $42=$2; + var $43=(($42+292)|0); + var $44=(($43+16)|0); + var $45=$44; + HEAP32[(($45)>>2)]=$41; + var $46=$2; + var $47=(($46+292)|0); + var $48=(($47)|0); + var $49=HEAP32[(($48)>>2)]; + $1=$49; + __label__ = 46; break; + case 11: + $ishex=1; + __label__ = 12; break; + case 12: + var $52=$ch; + var $53=(($52)|0)!=46; + if ($53) { __label__ = 13; break; } else { __label__ = 25; break; } + case 13: + var $55=$2; + var $56=$ch; + var $57=_lex_tokench($55, $56); + if ($57) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + var $59=$2; + var $60=(($59+292)|0); + var $61=(($60)|0); + HEAP32[(($61)>>2)]=143; + $1=143; + __label__ = 46; break; + case 15: + var $63=$2; + var $64=_lex_getch($63); + $ch=$64; + __label__ = 16; break; + case 16: + var $66=$ch; + var $67=_isdigit($66); + var $68=(($67)|0)!=0; + if ($68) { var $78 = 1;__label__ = 20; break; } else { __label__ = 17; break; } + case 17: + var $70=$ishex; + var $71=(($70) & 1); + if ($71) { __label__ = 18; break; } else { var $76 = 0;__label__ = 19; break; } + case 18: + var $73=$ch; + var $74=_isxdigit_only($73); + var $76 = $74;__label__ = 19; break; + case 19: + var $76; + var $78 = $76;__label__ = 20; break; + case 20: + var $78; + if ($78) { __label__ = 21; break; } else { __label__ = 24; break; } + case 21: + var $80=$2; + var $81=$ch; + var $82=_lex_tokench($80, $81); + if ($82) { __label__ = 23; break; } else { __label__ = 22; break; } + case 22: + var $84=$2; + var $85=(($84+292)|0); + var $86=(($85)|0); + HEAP32[(($86)>>2)]=143; + $1=143; + __label__ = 46; break; + case 23: + var $88=$2; + var $89=_lex_getch($88); + $ch=$89; + __label__ = 16; break; + case 24: + __label__ = 25; break; + case 25: + var $92=$ch; + var $93=(($92)|0)==46; + if ($93) { __label__ = 26; break; } else { __label__ = 35; break; } + case 26: + var $95=$ishex; + var $96=(($95) & 1); + if ($96) { __label__ = 35; break; } else { __label__ = 27; break; } + case 27: + var $98=$2; + var $99=(($98+292)|0); + var $100=(($99)|0); + HEAP32[(($100)>>2)]=138; + var $101=$2; + var $102=$ch; + var $103=_lex_tokench($101, $102); + if ($103) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + var $105=$2; + var $106=(($105+292)|0); + var $107=(($106)|0); + HEAP32[(($107)>>2)]=143; + $1=143; + __label__ = 46; break; + case 29: + var $109=$2; + var $110=_lex_getch($109); + $ch=$110; + __label__ = 30; break; + case 30: + var $112=$ch; + var $113=_isdigit($112); + var $114=(($113)|0)!=0; + if ($114) { __label__ = 31; break; } else { __label__ = 34; break; } + case 31: + var $116=$2; + var $117=$ch; + var $118=_lex_tokench($116, $117); + if ($118) { __label__ = 33; break; } else { __label__ = 32; break; } + case 32: + var $120=$2; + var $121=(($120+292)|0); + var $122=(($121)|0); + HEAP32[(($122)>>2)]=143; + $1=143; + __label__ = 46; break; + case 33: + var $124=$2; + var $125=_lex_getch($124); + $ch=$125; + __label__ = 30; break; + case 34: + __label__ = 35; break; + case 35: + var $128=$2; + var $129=(($128+292)|0); + var $130=(($129)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=(($131)|0)==138; + if ($132) { __label__ = 36; break; } else { __label__ = 38; break; } + case 36: + var $134=$ch; + var $135=(($134)|0)==102; + if ($135) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + var $137=$2; + var $138=_lex_getch($137); + $ch=$138; + __label__ = 38; break; + case 38: + var $140=$ch; + var $141=_isident($140); + if ($141) { __label__ = 39; break; } else { __label__ = 40; break; } + case 39: + var $143=$2; + _lexerror($143, ((STRING_TABLE.__str50435)|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)); + var $144=$2; + var $145=(($144+292)|0); + var $146=(($145)|0); + HEAP32[(($146)>>2)]=142; + $1=142; + __label__ = 46; break; + case 40: + var $148=$2; + var $149=$ch; + _lex_ungetch($148, $149); + var $150=$2; + var $151=_lex_endtoken($150); + if ($151) { __label__ = 42; break; } else { __label__ = 41; break; } + case 41: + var $153=$2; + var $154=(($153+292)|0); + var $155=(($154)|0); + HEAP32[(($155)>>2)]=143; + $1=143; + __label__ = 46; break; + case 42: + var $157=$2; + var $158=(($157+292)|0); + var $159=(($158)|0); + var $160=HEAP32[(($159)>>2)]; + var $161=(($160)|0)==138; + if ($161) { __label__ = 43; break; } else { __label__ = 44; break; } + case 43: + var $163=$2; + var $164=(($163+292)|0); + var $165=(($164+4)|0); + var $166=HEAP32[(($165)>>2)]; + var $167=_strtod($166, 0); + var $168=$2; + var $169=(($168+292)|0); + var $170=(($169+16)|0); + var $171=$170; + (tempDoubleF64[0]=$167,HEAP32[(($171)>>2)]=tempDoubleI32[0],HEAP32[((($171)+(4))>>2)]=tempDoubleI32[1]); + __label__ = 45; break; + case 44: + var $173=$2; + var $174=(($173+292)|0); + var $175=(($174+4)|0); + var $176=HEAP32[(($175)>>2)]; + var $177=_strtol($176, 0, 0); + var $178=$2; + var $179=(($178+292)|0); + var $180=(($179+16)|0); + var $181=$180; + HEAP32[(($181)>>2)]=$177; + __label__ = 45; break; + case 45: + var $183=$2; + var $184=(($183+292)|0); + var $185=(($184)|0); + var $186=HEAP32[(($185)>>2)]; + $1=$186; + __label__ = 46; break; + case 46: + var $188=$1; + STACKTOP = __stackBase__; + return $188; + default: assert(0, "bad label: " + __label__); + } +} +_lex_finish_digit["X"]=1; + +function _lex_parse_frame($lex) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ch; + $2=$lex; + var $3=$2; + _lex_token_new($3); + var $4=$2; + var $5=_lex_getch($4); + $ch=$5; + __label__ = 3; break; + case 3: + var $7=$ch; + var $8=(($7)|0)!=-1; + if ($8) { __label__ = 4; break; } else { var $17 = 0;__label__ = 6; break; } + case 4: + var $10=$ch; + var $11=(($10)|0)!=10; + if ($11) { __label__ = 5; break; } else { var $17 = 0;__label__ = 6; break; } + case 5: + var $13=$ch; + var $14=_isspace($13); + var $15=(($14)|0)!=0; + var $17 = $15;__label__ = 6; break; + case 6: + var $17; + if ($17) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $19=$2; + var $20=_lex_getch($19); + $ch=$20; + __label__ = 3; break; + case 8: + var $22=$ch; + var $23=(($22)|0)==10; + if ($23) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + $1=1; + __label__ = 19; break; + case 10: + var $26=$ch; + var $27=_isident_start($26); + if ($27) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $29=$2; + var $30=$ch; + _lexerror($29, ((STRING_TABLE.__str49434)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$30,tempInt)); + $1=-1; + __label__ = 19; break; + case 12: + var $32=$2; + var $33=$ch; + var $34=_lex_tokench($32, $33); + if ($34) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + $1=-1; + __label__ = 19; break; + case 14: + var $37=$2; + var $38=_lex_finish_ident($37); + if ($38) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=-1; + __label__ = 19; break; + case 16: + var $41=$2; + var $42=_lex_endtoken($41); + if ($42) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + $1=-1; + __label__ = 19; break; + case 18: + $1=0; + __label__ = 19; break; + case 19: + var $46=$1; + STACKTOP = __stackBase__; + return $46; + default: assert(0, "bad label: " + __label__); + } +} +_lex_parse_frame["X"]=1; + +function _lex_finish_string($lex, $quote) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $ch; + $2=$lex; + $3=$quote; + $ch=0; + __label__ = 3; break; + case 3: + var $5=$ch; + var $6=(($5)|0)!=-1; + if ($6) { __label__ = 4; break; } else { __label__ = 29; break; } + case 4: + var $8=$2; + var $9=_lex_getch($8); + $ch=$9; + var $10=$ch; + var $11=$3; + var $12=(($10)|0)==(($11)|0); + if ($12) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=134; + __label__ = 30; break; + case 6: + var $15=$2; + var $16=(($15+328)|0); + var $17=(($16+2)|0); + var $18=HEAP8[($17)]; + var $19=(($18) & 1); + if ($19) { __label__ = 25; break; } else { __label__ = 7; break; } + case 7: + var $21=$ch; + var $22=(($21)|0)==92; + if ($22) { __label__ = 8; break; } else { __label__ = 25; break; } + case 8: + var $24=$2; + var $25=_lex_getch($24); + $ch=$25; + var $26=$ch; + var $27=(($26)|0)==-1; + if ($27) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $29=$2; + _lexerror($29, ((STRING_TABLE.__str46431)|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)); + var $30=$2; + _lex_ungetch($30, -1); + var $31=$2; + var $32=(($31+292)|0); + var $33=(($32)|0); + HEAP32[(($33)>>2)]=142; + $1=142; + __label__ = 30; break; + case 10: + var $35=$ch; + if ((($35)|0) == 92) { + __label__ = 11; break; + } + else if ((($35)|0) == 97) { + __label__ = 12; break; + } + else if ((($35)|0) == 98) { + __label__ = 13; break; + } + else if ((($35)|0) == 114) { + __label__ = 14; break; + } + else if ((($35)|0) == 110) { + __label__ = 15; break; + } + else if ((($35)|0) == 116) { + __label__ = 16; break; + } + else if ((($35)|0) == 102) { + __label__ = 17; break; + } + else if ((($35)|0) == 118) { + __label__ = 18; break; + } + else { + __label__ = 19; break; + } + + case 11: + __label__ = 22; break; + case 12: + $ch=7; + __label__ = 22; break; + case 13: + $ch=8; + __label__ = 22; break; + case 14: + $ch=13; + __label__ = 22; break; + case 15: + $ch=10; + __label__ = 22; break; + case 16: + $ch=9; + __label__ = 22; break; + case 17: + $ch=12; + __label__ = 22; break; + case 18: + $ch=11; + __label__ = 22; break; + case 19: + var $45=$2; + var $46=$ch; + var $47=_lexwarn($45, 3, ((STRING_TABLE.__str47432)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$46,tempInt)); + var $48=$2; + var $49=_lex_tokench($48, 92); + if ($49) { __label__ = 21; break; } else { __label__ = 20; break; } + case 20: + var $51=$2; + var $52=(($51+292)|0); + var $53=(($52)|0); + HEAP32[(($53)>>2)]=143; + $1=143; + __label__ = 30; break; + case 21: + __label__ = 22; break; + case 22: + var $56=$2; + var $57=$ch; + var $58=_lex_tokench($56, $57); + if ($58) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $60=$2; + var $61=(($60+292)|0); + var $62=(($61)|0); + HEAP32[(($62)>>2)]=143; + $1=143; + __label__ = 30; break; + case 24: + __label__ = 28; break; + case 25: + var $65=$2; + var $66=$ch; + var $67=_lex_tokench($65, $66); + if ($67) { __label__ = 27; break; } else { __label__ = 26; break; } + case 26: + var $69=$2; + var $70=(($69+292)|0); + var $71=(($70)|0); + HEAP32[(($71)>>2)]=143; + $1=143; + __label__ = 30; break; + case 27: + __label__ = 28; break; + case 28: + __label__ = 3; break; + case 29: + var $75=$2; + _lexerror($75, ((STRING_TABLE.__str48433)|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)); + var $76=$2; + _lex_ungetch($76, -1); + var $77=$2; + var $78=(($77+292)|0); + var $79=(($78)|0); + HEAP32[(($79)>>2)]=142; + $1=142; + __label__ = 30; break; + case 30: + var $81=$1; + STACKTOP = __stackBase__; + return $81; + default: assert(0, "bad label: " + __label__); + } +} +_lex_finish_string["X"]=1; + +function _isident($ch) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$ch; + var $2=$1; + var $3=_isident_start($2); + if ($3) { var $9 = 1;__label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $5=$1; + var $6=_isdigit($5); + var $7=(($6)|0)!=0; + var $9 = $7;__label__ = 4; break; + case 4: + var $9; + ; + return $9; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_fgetc($lex) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$lex; + var $3=$2; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$2; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=_fgetc($10); + $1=$11; + __label__ = 9; break; + case 4: + var $13=$2; + var $14=(($13+4)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $18=$2; + var $19=(($18+12)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=$2; + var $22=(($21+8)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($20)>>>0) >= (($23)>>>0); + if ($24) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + $1=-1; + __label__ = 9; break; + case 7: + var $27=$2; + var $28=(($27+12)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=((($29)+(1))|0); + HEAP32[(($28)>>2)]=$30; + var $31=$2; + var $32=(($31+4)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33+$29)|0); + var $35=HEAP8[($34)]; + var $36=(($35 << 24) >> 24); + $1=$36; + __label__ = 9; break; + case 8: + $1=-1; + __label__ = 9; break; + case 9: + var $39=$1; + ; + return $39; + default: assert(0, "bad label: " + __label__); + } +} + + +function _lex_try_trigraph($lex, $old) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $c2; + var $c3; + $2=$lex; + $3=$old; + var $4=$2; + var $5=_lex_fgetc($4); + $c2=$5; + var $6=$c2; + var $7=(($6)|0)!=63; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$2; + var $10=$c2; + _lex_ungetch($9, $10); + var $11=$3; + $1=$11; + __label__ = 15; break; + case 4: + var $13=$2; + var $14=_lex_fgetc($13); + $c3=$14; + var $15=$c3; + if ((($15)|0) == 61) { + __label__ = 5; break; + } + else if ((($15)|0) == 47) { + __label__ = 6; break; + } + else if ((($15)|0) == 39) { + __label__ = 7; break; + } + else if ((($15)|0) == 40) { + __label__ = 8; break; + } + else if ((($15)|0) == 41) { + __label__ = 9; break; + } + else if ((($15)|0) == 33) { + __label__ = 10; break; + } + else if ((($15)|0) == 60) { + __label__ = 11; break; + } + else if ((($15)|0) == 62) { + __label__ = 12; break; + } + else if ((($15)|0) == 45) { + __label__ = 13; break; + } + else { + __label__ = 14; break; + } + + case 5: + $1=35; + __label__ = 15; break; + case 6: + $1=92; + __label__ = 15; break; + case 7: + $1=94; + __label__ = 15; break; + case 8: + $1=91; + __label__ = 15; break; + case 9: + $1=93; + __label__ = 15; break; + case 10: + $1=124; + __label__ = 15; break; + case 11: + $1=123; + __label__ = 15; break; + case 12: + $1=125; + __label__ = 15; break; + case 13: + $1=126; + __label__ = 15; break; + case 14: + var $26=$2; + var $27=$c3; + _lex_ungetch($26, $27); + var $28=$2; + var $29=$c2; + _lex_ungetch($28, $29); + var $30=$3; + $1=$30; + __label__ = 15; break; + case 15: + var $32=$1; + ; + return $32; + default: assert(0, "bad label: " + __label__); + } +} +_lex_try_trigraph["X"]=1; + +function _lex_try_digraph($lex, $ch) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $c2; + $2=$lex; + $3=$ch; + var $4=$2; + var $5=_lex_fgetc($4); + $c2=$5; + var $6=$3; + var $7=(($6)|0)==60; + if ($7) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $9=$c2; + var $10=(($9)|0)==58; + if ($10) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $1=91; + __label__ = 22; break; + case 5: + var $13=$3; + var $14=(($13)|0)==58; + if ($14) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $16=$c2; + var $17=(($16)|0)==62; + if ($17) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + $1=93; + __label__ = 22; break; + case 8: + var $20=$3; + var $21=(($20)|0)==60; + if ($21) { __label__ = 9; break; } else { __label__ = 11; break; } + case 9: + var $23=$c2; + var $24=(($23)|0)==37; + if ($24) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + $1=123; + __label__ = 22; break; + case 11: + var $27=$3; + var $28=(($27)|0)==37; + if ($28) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $30=$c2; + var $31=(($30)|0)==62; + if ($31) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + $1=125; + __label__ = 22; break; + case 14: + var $34=$3; + var $35=(($34)|0)==37; + if ($35) { __label__ = 15; break; } else { __label__ = 17; break; } + case 15: + var $37=$c2; + var $38=(($37)|0)==58; + if ($38) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + $1=35; + __label__ = 22; break; + case 17: + __label__ = 18; break; + case 18: + __label__ = 19; break; + case 19: + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + var $45=$2; + var $46=$c2; + _lex_ungetch($45, $46); + var $47=$3; + $1=$47; + __label__ = 22; break; + case 22: + var $49=$1; + ; + return $49; + default: assert(0, "bad label: " + __label__); + } +} +_lex_try_digraph["X"]=1; + +function _items_add($element_0, $element_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $element=__stackBase__; + var $temp; + var $2=(($element)|0); + HEAP32[(($2)>>2)]=$element_0; + var $3=(($element+4)|0); + HEAP32[(($3)>>2)]=$element_1; + $temp=0; + var $4=HEAP32[((_items_elements)>>2)]; + var $5=HEAP32[((_items_allocated)>>2)]; + var $6=(($4)|0)==(($5)|0); + if ($6) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $8=HEAP32[((_items_allocated)>>2)]; + var $9=(($8)|0)==0; + if ($9) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + HEAP32[((_items_allocated)>>2)]=12; + __label__ = 6; break; + case 5: + var $12=HEAP32[((_items_allocated)>>2)]; + var $13=((($12<<1))|0); + HEAP32[((_items_allocated)>>2)]=$13; + __label__ = 6; break; + case 6: + var $15=HEAP32[((_items_allocated)>>2)]; + var $16=((($15<<3))|0); + var $17=_util_memory_a($16, 48, ((STRING_TABLE.__str1448)|0)); + $temp=$17; + var $18=(($17)|0)!=0; + if ($18) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $20=$temp; + _util_memory_d($20, 48, ((STRING_TABLE.__str1448)|0)); + $1=-1; + __label__ = 10; break; + case 8: + var $22=$temp; + var $23=HEAP32[((_items_data)>>2)]; + var $24=$23; + var $25=HEAP32[((_items_elements)>>2)]; + var $26=((($25<<3))|0); + assert($26 % 1 === 0, 'memcpy given ' + $26 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($22, $24, $26, 1); + var $27=HEAP32[((_items_data)>>2)]; + var $28=$27; + _util_memory_d($28, 48, ((STRING_TABLE.__str1448)|0)); + var $29=$temp; + var $30=$29; + HEAP32[((_items_data)>>2)]=$30; + __label__ = 9; break; + case 9: + var $32=HEAP32[((_items_elements)>>2)]; + var $33=HEAP32[((_items_data)>>2)]; + var $34=(($33+($32<<3))|0); + var $35=$34; + var $36=$element; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($35)>>2)]=HEAP32[(($36)>>2)];HEAP32[((($35)+(4))>>2)]=HEAP32[((($36)+(4))>>2)]; + var $37=HEAP32[((_items_elements)>>2)]; + var $38=((($37)+(1))|0); + HEAP32[((_items_elements)>>2)]=$38; + $1=$37; + __label__ = 10; break; + case 10: + var $40=$1; + STACKTOP = __stackBase__; + return $40; + default: assert(0, "bad label: " + __label__); + } +} +_items_add["X"]=1; + +function _options_set($flags, $idx, $on) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $lb; + $1=$flags; + $2=$idx; + var $4=(($on)&1); + $3=$4; + var $5=$2; + $lb=$5; + var $6=$3; + var $7=(($6) & 1); + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$lb; + var $10=1 << $9; + var $11=$1; + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$13 | $10; + HEAP32[(($12)>>2)]=$14; + __label__ = 5; break; + case 4: + var $16=$lb; + var $17=1 << $16; + var $18=$17 ^ -1; + var $19=$1; + var $20=(($19)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$21 & $18; + HEAP32[(($20)>>2)]=$22; + __label__ = 5; break; + case 5: + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _main($argc, $argv) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $itr; + var $retval; + var $opts_output_free; + var $src; + var $line=__stackBase__; + var $linelen=(__stackBase__)+(4); + $1=0; + $2=$argc; + $3=$argv; + $retval=0; + $opts_output_free=0; + var $4=$3; + var $5=(($4)|0); + var $6=HEAP32[(($5)>>2)]; + HEAP32[((_app_name)>>2)]=$6; + _options_set(((_opts_warn)|0), 3, 1); + _options_set(((_opts_warn)|0), 4, 1); + _options_set(((_opts_warn)|0), 5, 1); + _options_set(((_opts_warn)|0), 7, 1); + _options_set(((_opts_warn)|0), 6, 1); + _options_set(((_opts_warn)|0), 2, 1); + _options_set(((_opts_warn)|0), 9, 1); + _options_set(((_opts_warn)|0), 10, 1); + _options_set(((_opts_warn)|0), 11, 1); + _options_set(((_opts_warn)|0), 12, 1); + _options_set(((_opts_warn)|0), 13, 1); + _options_set(((_opts_warn)|0), 1, 1); + _options_set(((_opts_warn)|0), 14, 1); + _options_set(((_opts_warn)|0), 15, 1); + _options_set(((_opts_warn)|0), 16, 1); + var $7=$2; + var $8=$3; + var $9=_options_parse($7, $8); + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $11=_usage(); + $1=$11; + __label__ = 51; break; + case 4: + var $13=HEAP32[((_opts_standard)>>2)]; + var $14=(($13)|0)==3; + if ($14) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + HEAP32[((_operators)>>2)]=((_c_operators)|0); + HEAP32[((_operator_count)>>2)]=42; + __label__ = 7; break; + case 6: + HEAP32[((_operators)>>2)]=((_qcc_operators)|0); + HEAP32[((_operator_count)>>2)]=29; + __label__ = 7; break; + case 7: + var $18=HEAP8[(_opts_dump)]; + var $19=(($18) & 1); + if ($19) { __label__ = 8; break; } else { __label__ = 17; break; } + case 8: + $itr=0; + __label__ = 9; break; + case 9: + var $22=$itr; + var $23=(($22)>>>0) < 4; + if ($23) { __label__ = 10; break; } else { __label__ = 12; break; } + case 10: + var $25=$itr; + var $26=((_opts_flag_list+($25<<3))|0); + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$itr; + var $30=Math.floor(((($29)>>>0))/(32)); + var $31=((_opts_flags+($30<<2))|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$itr; + var $34=((($33)>>>0))%(32); + var $35=1 << $34; + var $36=$32 & $35; + var $37=(($36)|0)!=0; + var $38=$37 ^ 1; + var $39=$38 ^ 1; + var $40=(($39)&1); + var $41=_printf(((STRING_TABLE.__str2451)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$28,HEAP32[(((tempInt)+(4))>>2)]=$40,tempInt)); + __label__ = 11; break; + case 11: + var $43=$itr; + var $44=((($43)+(1))|0); + $itr=$44; + __label__ = 9; break; + case 12: + $itr=0; + __label__ = 13; break; + case 13: + var $47=$itr; + var $48=(($47)>>>0) < 17; + if ($48) { __label__ = 14; break; } else { __label__ = 16; break; } + case 14: + var $50=$itr; + var $51=((_opts_warn_list+($50<<3))|0); + var $52=(($51)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=$itr; + var $55=Math.floor(((($54)>>>0))/(32)); + var $56=((_opts_warn+($55<<2))|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$itr; + var $59=((($58)>>>0))%(32); + var $60=1 << $59; + var $61=$57 & $60; + var $62=(($61)|0)!=0; + var $63=$62 ^ 1; + var $64=$63 ^ 1; + var $65=(($64)&1); + var $66=_printf(((STRING_TABLE.__str3454)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$53,HEAP32[(((tempInt)+(4))>>2)]=$65,tempInt)); + __label__ = 15; break; + case 15: + var $68=$itr; + var $69=((($68)+(1))|0); + $itr=$69; + __label__ = 13; break; + case 16: + var $71=HEAP32[((_opts_output)>>2)]; + var $72=_printf(((STRING_TABLE.__str4455)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$71,tempInt)); + var $73=HEAP32[((_opts_O)>>2)]; + var $74=_printf(((STRING_TABLE.__str5456)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$73,tempInt)); + var $75=HEAP32[((_opts_standard)>>2)]; + var $76=_printf(((STRING_TABLE.__str6457)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$75,tempInt)); + __label__ = 17; break; + case 17: + var $78=_parser_init(); + if ($78) { __label__ = 19; break; } else { __label__ = 18; break; } + case 18: + var $80=_printf(((STRING_TABLE.__str7458)|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)); + $retval=1; + __label__ = 48; break; + case 19: + _util_debug(((STRING_TABLE.__str8459)|0), ((STRING_TABLE.__str9460)|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)); + var $82=HEAP32[((_items_elements)>>2)]; + var $83=(($82)|0)!=0; + if ($83) { __label__ = 20; break; } else { __label__ = 29; break; } + case 20: + var $85=_printf(((STRING_TABLE.__str10461)|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)); + var $86=HEAP32[((_items_elements)>>2)]; + var $87=_printf(((STRING_TABLE.__str11462)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$86,tempInt)); + $itr=0; + __label__ = 21; break; + case 21: + var $89=$itr; + var $90=HEAP32[((_items_elements)>>2)]; + var $91=(($89)>>>0) < (($90)>>>0); + if ($91) { __label__ = 22; break; } else { __label__ = 26; break; } + case 22: + var $93=$itr; + var $94=HEAP32[((_items_data)>>2)]; + var $95=(($94+($93<<3))|0); + var $96=(($95)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=_parser_compile_string(((STRING_TABLE.__str12463)|0), $97); + if ($98) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + $retval=1; + __label__ = 48; break; + case 24: + __label__ = 25; break; + case 25: + var $102=$itr; + var $103=((($102)+(1))|0); + $itr=$103; + __label__ = 21; break; + case 26: + var $105=HEAP32[((_opts_output)>>2)]; + var $106=_parser_finish($105); + if ($106) { __label__ = 28; break; } else { __label__ = 27; break; } + case 27: + $retval=1; + __label__ = 48; break; + case 28: + __label__ = 47; break; + case 29: + HEAP32[(($linelen)>>2)]=0; + var $110=_printf(((STRING_TABLE.__str13464)|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)); + var $111=_util_fopen(((STRING_TABLE.__str14465)|0), ((STRING_TABLE.__str15466)|0)); + $src=$111; + var $112=$src; + var $113=(($112)|0)!=0; + if ($113) { __label__ = 31; break; } else { __label__ = 30; break; } + case 30: + var $115=_printf(((STRING_TABLE.__str16467)|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)); + $retval=1; + __label__ = 48; break; + case 31: + HEAP32[(($line)>>2)]=0; + var $117=$src; + var $118=_progs_nextline($line, $linelen, $117); + if ($118) { __label__ = 32; break; } else { __label__ = 33; break; } + case 32: + var $120=HEAP32[(($line)>>2)]; + var $121=(($120)|0); + var $122=HEAP8[($121)]; + var $123=(($122 << 24) >> 24)!=0; + if ($123) { __label__ = 34; break; } else { __label__ = 33; break; } + case 33: + var $125=_printf(((STRING_TABLE.__str17468)|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)); + $retval=1; + __label__ = 46; break; + case 34: + var $127=HEAP8[(_opts_output_wasset)]; + var $128=(($127) & 1); + if ($128) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + var $130=HEAP32[(($line)>>2)]; + var $131=_util_strdup($130); + HEAP32[((_opts_output)>>2)]=$131; + $opts_output_free=1; + __label__ = 36; break; + case 36: + __label__ = 37; break; + case 37: + var $134=$src; + var $135=_progs_nextline($line, $linelen, $134); + if ($135) { __label__ = 38; break; } else { __label__ = 45; break; } + case 38: + var $137=HEAP32[(($line)>>2)]; + var $138=(($137)|0); + var $139=HEAP8[($138)]; + var $140=(($139 << 24) >> 24)!=0; + if ($140) { __label__ = 39; break; } else { __label__ = 41; break; } + case 39: + var $142=HEAP32[(($line)>>2)]; + var $143=(($142)|0); + var $144=HEAP8[($143)]; + var $145=(($144 << 24) >> 24); + var $146=(($145)|0)==47; + if ($146) { __label__ = 40; break; } else { __label__ = 42; break; } + case 40: + var $148=HEAP32[(($line)>>2)]; + var $149=(($148+1)|0); + var $150=HEAP8[($149)]; + var $151=(($150 << 24) >> 24); + var $152=(($151)|0)==47; + if ($152) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + __label__ = 37; break; + case 42: + var $155=HEAP32[(($line)>>2)]; + var $156=_printf(((STRING_TABLE.__str18469)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$155,tempInt)); + var $157=HEAP32[(($line)>>2)]; + var $158=_parser_compile_file($157); + if ($158) { __label__ = 44; break; } else { __label__ = 43; break; } + case 43: + $retval=1; + __label__ = 46; break; + case 44: + __label__ = 37; break; + case 45: + var $162=HEAP32[((_opts_output)>>2)]; + var $163=_parser_finish($162); + __label__ = 46; break; + case 46: + var $165=$src; + var $166=_fclose($165); + var $167=HEAP32[(($line)>>2)]; + _util_memory_d($167, 520, ((STRING_TABLE.__str1448)|0)); + __label__ = 47; break; + case 47: + __label__ = 48; break; + case 48: + _util_debug(((STRING_TABLE.__str8459)|0), ((STRING_TABLE.__str19470)|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)); + var $170=HEAP32[((_items_data)>>2)]; + var $171=$170; + _util_memory_d($171, 528, ((STRING_TABLE.__str1448)|0)); + _parser_cleanup(); + var $172=$opts_output_free; + var $173=(($172) & 1); + if ($173) { __label__ = 49; break; } else { __label__ = 50; break; } + case 49: + var $175=HEAP32[((_opts_output)>>2)]; + _util_memory_d($175, 532, ((STRING_TABLE.__str1448)|0)); + __label__ = 50; break; + case 50: + _lex_cleanup(); + _util_meminfo(); + var $177=$retval; + $1=$177; + __label__ = 51; break; + case 51: + var $179=$1; + STACKTOP = __stackBase__; + return $179; + default: assert(0, "bad label: " + __label__); + } +} +Module["_main"] = _main;_main["X"]=1; + +function _options_witharg($argc_, $argv_, $out) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $argc; + var $argv; + $2=$argc_; + $3=$argv_; + $4=$out; + var $5=$2; + var $6=HEAP32[(($5)>>2)]; + $argc=$6; + var $7=$3; + var $8=HEAP32[(($7)>>2)]; + $argv=$8; + var $9=$argv; + var $10=(($9)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($11+2)|0); + var $13=HEAP8[($12)]; + var $14=(($13 << 24) >> 24)!=0; + if ($14) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $16=$argv; + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+2)|0); + var $20=$4; + HEAP32[(($20)>>2)]=$19; + $1=1; + __label__ = 7; break; + case 4: + var $22=$argc; + var $23=(($22)|0) < 2; + if ($23) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 7; break; + case 6: + var $26=$argv; + var $27=(($26+4)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=$4; + HEAP32[(($29)>>2)]=$28; + var $30=$2; + var $31=HEAP32[(($30)>>2)]; + var $32=((($31)-(1))|0); + HEAP32[(($30)>>2)]=$32; + var $33=$3; + var $34=HEAP32[(($33)>>2)]; + var $35=(($34+4)|0); + HEAP32[(($33)>>2)]=$35; + $1=1; + __label__ = 7; break; + case 7: + var $37=$1; + ; + return $37; + default: assert(0, "bad label: " + __label__); + } +} +_options_witharg["X"]=1; + +function _progs_nextline($out, $alen, $src) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $len; + var $line=__stackBase__; + var $start; + var $end; + $2=$out; + $3=$alen; + $4=$src; + var $5=$2; + var $6=HEAP32[(($5)>>2)]; + HEAP32[(($line)>>2)]=$6; + var $7=$3; + var $8=$4; + var $9=_util_getline($line, $7, $8); + $len=$9; + var $10=$len; + var $11=(($10)|0)==-1; + if ($11) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 18; break; + case 4: + var $14=HEAP32[(($line)>>2)]; + $start=$14; + __label__ = 5; break; + case 5: + var $16=$start; + var $17=HEAP8[($16)]; + var $18=(($17 << 24) >> 24); + var $19=_isspace($18); + var $20=(($19)|0)!=0; + if ($20) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + __label__ = 7; break; + case 7: + var $23=$start; + var $24=(($23+1)|0); + $start=$24; + __label__ = 5; break; + case 8: + var $26=$start; + $end=$26; + __label__ = 9; break; + case 9: + var $28=$end; + var $29=HEAP8[($28)]; + var $30=(($29 << 24) >> 24); + var $31=(($30)|0)!=0; + if ($31) { __label__ = 10; break; } else { var $40 = 0;__label__ = 11; break; } + case 10: + var $33=$end; + var $34=HEAP8[($33)]; + var $35=(($34 << 24) >> 24); + var $36=_isspace($35); + var $37=(($36)|0)!=0; + var $38=$37 ^ 1; + var $40 = $38;__label__ = 11; break; + case 11: + var $40; + if ($40) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + __label__ = 13; break; + case 13: + var $43=$end; + var $44=(($43+1)|0); + $end=$44; + __label__ = 9; break; + case 14: + var $46=HEAP32[(($line)>>2)]; + var $47=$2; + HEAP32[(($47)>>2)]=$46; + __label__ = 15; break; + case 15: + var $49=$start; + var $50=$end; + var $51=(($49)|0)!=(($50)|0); + if ($51) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + var $53=$start; + var $54=(($53+1)|0); + $start=$54; + var $55=HEAP8[($53)]; + var $56=HEAP32[(($line)>>2)]; + var $57=(($56+1)|0); + HEAP32[(($line)>>2)]=$57; + HEAP8[($56)]=$55; + __label__ = 15; break; + case 17: + var $59=HEAP32[(($line)>>2)]; + HEAP8[($59)]=0; + $1=1; + __label__ = 18; break; + case 18: + var $61=$1; + STACKTOP = __stackBase__; + return $61; + default: assert(0, "bad label: " + __label__); + } +} +_progs_nextline["X"]=1; + +function _usage() { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1=HEAP32[((_app_name)>>2)]; + var $2=_printf(((STRING_TABLE.__str78531)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1,tempInt)); + var $3=_printf(((STRING_TABLE.__str79532)|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)); + var $4=_printf(((STRING_TABLE.__str80533)|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)); + var $5=_printf(((STRING_TABLE.__str81534)|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)); + var $6=_printf(((STRING_TABLE.__str82535)|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)); + var $7=_printf(((STRING_TABLE.__str83536)|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)); + var $8=_printf(((STRING_TABLE.__str84537)|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)); + var $9=_printf(((STRING_TABLE.__str85538)|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)); + var $10=_printf(((STRING_TABLE.__str86539)|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)); + STACKTOP = __stackBase__; + return -1; +} + + +function _options_long_gcc($optname, $argc_, $argv_, $out) { + ; + var __label__; + + var $1; + var $2; + var $3; + var $4; + $1=$optname; + $2=$argc_; + $3=$argv_; + $4=$out; + var $5=$1; + var $6=$2; + var $7=$3; + var $8=$4; + var $9=_options_long_witharg_all($5, $6, $7, $8, 1, 0); + ; + return $9; +} + + +function _options_setflag($name, $on) { + ; + var __label__; + + var $1; + var $2; + $1=$name; + var $3=(($on)&1); + $2=$3; + var $4=$1; + var $5=$2; + var $6=(($5) & 1); + var $7=_options_setflag_all($4, $6, ((_opts_flags)|0), ((_opts_flag_list)|0), 4); + ; + return $7; +} + + +function _options_setwarn($name, $on) { + ; + var __label__; + + var $1; + var $2; + $1=$name; + var $3=(($on)&1); + $2=$3; + var $4=$1; + var $5=$2; + var $6=(($5) & 1); + var $7=_options_setflag_all($4, $6, ((_opts_warn)|0), ((_opts_warn_list)|0), 17); + ; + return $7; +} + + +function _options_long_witharg($optname, $argc_, $argv_, $out) { + ; + var __label__; + + var $1; + var $2; + var $3; + var $4; + $1=$optname; + $2=$argc_; + $3=$argv_; + $4=$out; + var $5=$1; + var $6=$2; + var $7=$3; + var $8=$4; + var $9=_options_long_witharg_all($5, $6, $7, $8, 2, 1); + ; + return $9; +} + + +function _options_parse($argc, $argv) { + var __stackBase__ = STACKTOP; STACKTOP += 1052; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2=__stackBase__; + var $3=(__stackBase__)+(4); + var $argend; + var $itr; + var $buffer=(__stackBase__)+(8); + var $argarg=(__stackBase__)+(1032); + var $item=(__stackBase__)+(1036); + var $item1=(__stackBase__)+(1044); + HEAP32[(($2)>>2)]=$argc; + HEAP32[(($3)>>2)]=$argv; + $argend=0; + __label__ = 3; break; + case 3: + var $5=$argend; + var $6=(($5) & 1); + if ($6) { var $11 = 0;__label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $8=HEAP32[(($2)>>2)]; + var $9=(($8)|0) > 1; + var $11 = $9;__label__ = 5; break; + case 5: + var $11; + if ($11) { __label__ = 6; break; } else { __label__ = 106; break; } + case 6: + var $13=HEAP32[(($3)>>2)]; + var $14=(($13+4)|0); + HEAP32[(($3)>>2)]=$14; + var $15=HEAP32[(($2)>>2)]; + var $16=((($15)-(1))|0); + HEAP32[(($2)>>2)]=$16; + var $17=HEAP32[(($3)>>2)]; + var $18=(($17)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($19)|0); + var $21=HEAP8[($20)]; + var $22=(($21 << 24) >> 24); + var $23=(($22)|0)==45; + if ($23) { __label__ = 7; break; } else { __label__ = 104; break; } + case 7: + var $25=_options_long_gcc(((STRING_TABLE.__str87540)|0), $2, $3, $argarg); + if ($25) { __label__ = 8; break; } else { __label__ = 23; break; } + case 8: + var $27=HEAP32[(($argarg)>>2)]; + var $28=_strcmp($27, ((STRING_TABLE.__str88541)|0)); + var $29=(($28)|0)!=0; + if ($29) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $31=HEAP32[(($argarg)>>2)]; + var $32=_strcmp($31, ((STRING_TABLE.__str89542)|0)); + var $33=(($32)|0)!=0; + if ($33) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + HEAP32[((_opts_standard)>>2)]=3; + __label__ = 22; break; + case 11: + var $36=HEAP32[(($argarg)>>2)]; + var $37=_strcmp($36, ((STRING_TABLE.__str90543)|0)); + var $38=(($37)|0)!=0; + if ($38) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + HEAP32[((_opts_standard)>>2)]=0; + __label__ = 21; break; + case 13: + var $41=HEAP32[(($argarg)>>2)]; + var $42=_strcmp($41, ((STRING_TABLE.__str91544)|0)); + var $43=(($42)|0)!=0; + if ($43) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + var $45=HEAP32[(($argarg)>>2)]; + var $46=_strcmp($45, ((STRING_TABLE.__str92545)|0)); + var $47=(($46)|0)!=0; + if ($47) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + HEAP32[((_opts_standard)>>2)]=1; + __label__ = 20; break; + case 16: + var $50=HEAP32[(($argarg)>>2)]; + var $51=_strcmp($50, ((STRING_TABLE.__str93546)|0)); + var $52=(($51)|0)!=0; + if ($52) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + HEAP32[((_opts_standard)>>2)]=2; + __label__ = 19; break; + case 18: + var $55=HEAP32[(($argarg)>>2)]; + var $56=_printf(((STRING_TABLE.__str94547)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$55,tempInt)); + $1=0; + __label__ = 107; break; + case 19: + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + __label__ = 22; break; + case 22: + __label__ = 3; break; + case 23: + var $62=_options_long_gcc(((STRING_TABLE.__str95548)|0), $2, $3, $argarg); + if ($62) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + HEAP8[(_opts_forcecrc)]=1; + var $64=HEAP32[(($argarg)>>2)]; + var $65=_strtol($64, 0, 0); + var $66=(($65) & 65535); + HEAP16[((_opts_forced_crc)>>1)]=$66; + __label__ = 3; break; + case 25: + var $68=HEAP32[(($3)>>2)]; + var $69=(($68)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($70+1)|0); + var $72=_strcmp($71, ((STRING_TABLE.__str96549)|0)); + var $73=(($72)|0)!=0; + if ($73) { __label__ = 27; break; } else { __label__ = 26; break; } + case 26: + HEAP8[(_opts_debug)]=1; + __label__ = 3; break; + case 27: + var $76=HEAP32[(($3)>>2)]; + var $77=(($76)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($78+1)|0); + var $80=_strcmp($79, ((STRING_TABLE.__str97550)|0)); + var $81=(($80)|0)!=0; + if ($81) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + HEAP8[(_opts_dump)]=1; + __label__ = 3; break; + case 29: + var $84=HEAP32[(($3)>>2)]; + var $85=(($84)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=(($86+1)|0); + var $88=_strcmp($87, ((STRING_TABLE.__str98551)|0)); + var $89=(($88)|0)!=0; + if ($89) { __label__ = 31; break; } else { __label__ = 30; break; } + case 30: + HEAP8[(_opts_memchk)]=1; + __label__ = 3; break; + case 31: + var $92=HEAP32[(($3)>>2)]; + var $93=(($92)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=(($94+1)|0); + var $96=HEAP8[($95)]; + var $97=(($96 << 24) >> 24); + if ((($97)|0) == 104) { + __label__ = 32; break; + } + else if ((($97)|0) == 69) { + __label__ = 33; break; + } + else if ((($97)|0) == 102) { + __label__ = 34; break; + } + else if ((($97)|0) == 87) { + __label__ = 49; break; + } + else if ((($97)|0) == 79) { + __label__ = 83; break; + } + else if ((($97)|0) == 111) { + __label__ = 86; break; + } + else if ((($97)|0) == 97 || (($97)|0) == 115) { + __label__ = 89; break; + } + else if ((($97)|0) == 45) { + __label__ = 92; break; + } + else { + __label__ = 102; break; + } + + case 32: + var $99=_usage(); + _exit(0); + throw "Reached an unreachable!" + case 33: + HEAP8[(_opts_pp_only)]=1; + __label__ = 103; break; + case 34: + var $102=HEAP32[(($3)>>2)]; + var $103=(($102)|0); + var $104=HEAP32[(($103)>>2)]; + var $105=(($104+2)|0); + var $106=HEAP32[(($3)>>2)]; + var $107=(($106)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108+2)|0); + var $110=HEAP32[(($3)>>2)]; + var $111=(($110)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($112+2)|0); + var $114=_strlen($113); + var $115=((($114)+(1))|0); + var $116=_util_strtocmd($105, $109, $115); + var $117=HEAP32[(($3)>>2)]; + var $118=(($117)|0); + var $119=HEAP32[(($118)>>2)]; + var $120=(($119+2)|0); + var $121=_strcmp($120, ((STRING_TABLE.__str99552)|0)); + var $122=(($121)|0)!=0; + if ($122) { __label__ = 40; break; } else { __label__ = 35; break; } + case 35: + var $124=_printf(((STRING_TABLE.__str100553)|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)); + $itr=0; + __label__ = 36; break; + case 36: + var $126=$itr; + var $127=(($126)>>>0) < 4; + if ($127) { __label__ = 37; break; } else { __label__ = 39; break; } + case 37: + var $129=$itr; + var $130=((_opts_flag_list+($129<<3))|0); + var $131=(($130)|0); + var $132=HEAP32[(($131)>>2)]; + var $133=(($buffer)|0); + var $134=_util_strtononcmd($132, $133, 1024); + var $135=(($buffer)|0); + var $136=_printf(((STRING_TABLE.__str101554)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$135,tempInt)); + __label__ = 38; break; + case 38: + var $138=$itr; + var $139=((($138)+(1))|0); + $itr=$139; + __label__ = 36; break; + case 39: + _exit(0); + throw "Reached an unreachable!" + case 40: + var $142=HEAP32[(($3)>>2)]; + var $143=(($142)|0); + var $144=HEAP32[(($143)>>2)]; + var $145=(($144+2)|0); + var $146=_strncmp($145, ((STRING_TABLE.__str102555)|0), 3); + var $147=(($146)|0)!=0; + if ($147) { __label__ = 44; break; } else { __label__ = 41; break; } + case 41: + var $149=HEAP32[(($3)>>2)]; + var $150=(($149)|0); + var $151=HEAP32[(($150)>>2)]; + var $152=(($151+5)|0); + var $153=_options_setflag($152, 0); + if ($153) { __label__ = 43; break; } else { __label__ = 42; break; } + case 42: + var $155=HEAP32[(($3)>>2)]; + var $156=(($155)|0); + var $157=HEAP32[(($156)>>2)]; + var $158=(($157+2)|0); + var $159=_printf(((STRING_TABLE.__str103556)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$158,tempInt)); + $1=0; + __label__ = 107; break; + case 43: + __label__ = 47; break; + case 44: + var $162=HEAP32[(($3)>>2)]; + var $163=(($162)|0); + var $164=HEAP32[(($163)>>2)]; + var $165=(($164+2)|0); + var $166=_options_setflag($165, 1); + if ($166) { __label__ = 46; break; } else { __label__ = 45; break; } + case 45: + var $168=HEAP32[(($3)>>2)]; + var $169=(($168)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=(($170+2)|0); + var $172=_printf(((STRING_TABLE.__str103556)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$171,tempInt)); + $1=0; + __label__ = 107; break; + case 46: + __label__ = 47; break; + case 47: + __label__ = 48; break; + case 48: + __label__ = 103; break; + case 49: + var $177=HEAP32[(($3)>>2)]; + var $178=(($177)|0); + var $179=HEAP32[(($178)>>2)]; + var $180=(($179+2)|0); + var $181=HEAP32[(($3)>>2)]; + var $182=(($181)|0); + var $183=HEAP32[(($182)>>2)]; + var $184=(($183+2)|0); + var $185=HEAP32[(($3)>>2)]; + var $186=(($185)|0); + var $187=HEAP32[(($186)>>2)]; + var $188=(($187+2)|0); + var $189=_strlen($188); + var $190=((($189)+(1))|0); + var $191=_util_strtocmd($180, $184, $190); + var $192=HEAP32[(($3)>>2)]; + var $193=(($192)|0); + var $194=HEAP32[(($193)>>2)]; + var $195=(($194+2)|0); + var $196=_strcmp($195, ((STRING_TABLE.__str99552)|0)); + var $197=(($196)|0)!=0; + if ($197) { __label__ = 55; break; } else { __label__ = 50; break; } + case 50: + var $199=_printf(((STRING_TABLE.__str104557)|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)); + $itr=0; + __label__ = 51; break; + case 51: + var $201=$itr; + var $202=(($201)>>>0) < 17; + if ($202) { __label__ = 52; break; } else { __label__ = 54; break; } + case 52: + var $204=$itr; + var $205=((_opts_warn_list+($204<<3))|0); + var $206=(($205)|0); + var $207=HEAP32[(($206)>>2)]; + var $208=(($buffer)|0); + var $209=_util_strtononcmd($207, $208, 1024); + var $210=(($buffer)|0); + var $211=_printf(((STRING_TABLE.__str105558)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$210,tempInt)); + __label__ = 53; break; + case 53: + var $213=$itr; + var $214=((($213)+(1))|0); + $itr=$214; + __label__ = 51; break; + case 54: + _exit(0); + throw "Reached an unreachable!" + case 55: + var $217=HEAP32[(($3)>>2)]; + var $218=(($217)|0); + var $219=HEAP32[(($218)>>2)]; + var $220=(($219+2)|0); + var $221=_strcmp($220, ((STRING_TABLE.__str106559)|0)); + var $222=(($221)|0)!=0; + if ($222) { __label__ = 57; break; } else { __label__ = 56; break; } + case 56: + HEAP8[(_opts_werror)]=0; + __label__ = 103; break; + case 57: + var $225=HEAP32[(($3)>>2)]; + var $226=(($225)|0); + var $227=HEAP32[(($226)>>2)]; + var $228=(($227+2)|0); + var $229=_strcmp($228, ((STRING_TABLE.__str107560)|0)); + var $230=(($229)|0)!=0; + if ($230) { __label__ = 59; break; } else { __label__ = 58; break; } + case 58: + HEAP8[(_opts_werror)]=1; + __label__ = 103; break; + case 59: + var $233=HEAP32[(($3)>>2)]; + var $234=(($233)|0); + var $235=HEAP32[(($234)>>2)]; + var $236=(($235+2)|0); + var $237=_strcmp($236, ((STRING_TABLE.__str108561)|0)); + var $238=(($237)|0)!=0; + if ($238) { __label__ = 65; break; } else { __label__ = 60; break; } + case 60: + $itr=0; + __label__ = 61; break; + case 61: + var $241=$itr; + var $242=(($241)>>>0) < 1; + if ($242) { __label__ = 62; break; } else { __label__ = 64; break; } + case 62: + var $244=$itr; + var $245=((_opts_warn+($244<<2))|0); + HEAP32[(($245)>>2)]=0; + __label__ = 63; break; + case 63: + var $247=$itr; + var $248=((($247)+(1))|0); + $itr=$248; + __label__ = 61; break; + case 64: + __label__ = 103; break; + case 65: + var $251=HEAP32[(($3)>>2)]; + var $252=(($251)|0); + var $253=HEAP32[(($252)>>2)]; + var $254=(($253+2)|0); + var $255=_strcmp($254, ((STRING_TABLE.__str109562)|0)); + var $256=(($255)|0)!=0; + if ($256) { __label__ = 71; break; } else { __label__ = 66; break; } + case 66: + $itr=0; + __label__ = 67; break; + case 67: + var $259=$itr; + var $260=(($259)>>>0) < 1; + if ($260) { __label__ = 68; break; } else { __label__ = 70; break; } + case 68: + var $262=$itr; + var $263=((_opts_warn+($262<<2))|0); + HEAP32[(($263)>>2)]=-1; + __label__ = 69; break; + case 69: + var $265=$itr; + var $266=((($265)+(1))|0); + $itr=$266; + __label__ = 67; break; + case 70: + __label__ = 103; break; + case 71: + __label__ = 72; break; + case 72: + __label__ = 73; break; + case 73: + __label__ = 74; break; + case 74: + __label__ = 75; break; + case 75: + var $273=HEAP32[(($3)>>2)]; + var $274=(($273)|0); + var $275=HEAP32[(($274)>>2)]; + var $276=(($275+2)|0); + var $277=_strncmp($276, ((STRING_TABLE.__str102555)|0), 3); + var $278=(($277)|0)!=0; + if ($278) { __label__ = 79; break; } else { __label__ = 76; break; } + case 76: + var $280=HEAP32[(($3)>>2)]; + var $281=(($280)|0); + var $282=HEAP32[(($281)>>2)]; + var $283=(($282+5)|0); + var $284=_options_setwarn($283, 0); + if ($284) { __label__ = 78; break; } else { __label__ = 77; break; } + case 77: + var $286=HEAP32[(($3)>>2)]; + var $287=(($286)|0); + var $288=HEAP32[(($287)>>2)]; + var $289=(($288+2)|0); + var $290=_printf(((STRING_TABLE.__str110563)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$289,tempInt)); + $1=0; + __label__ = 107; break; + case 78: + __label__ = 82; break; + case 79: + var $293=HEAP32[(($3)>>2)]; + var $294=(($293)|0); + var $295=HEAP32[(($294)>>2)]; + var $296=(($295+2)|0); + var $297=_options_setwarn($296, 1); + if ($297) { __label__ = 81; break; } else { __label__ = 80; break; } + case 80: + var $299=HEAP32[(($3)>>2)]; + var $300=(($299)|0); + var $301=HEAP32[(($300)>>2)]; + var $302=(($301+2)|0); + var $303=_printf(((STRING_TABLE.__str110563)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$302,tempInt)); + $1=0; + __label__ = 107; break; + case 81: + __label__ = 82; break; + case 82: + __label__ = 103; break; + case 83: + var $307=_options_witharg($2, $3, $argarg); + if ($307) { __label__ = 85; break; } else { __label__ = 84; break; } + case 84: + var $309=_printf(((STRING_TABLE.__str111564)|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)); + $1=0; + __label__ = 107; break; + case 85: + var $311=HEAP32[(($argarg)>>2)]; + var $312=_atoi($311); + HEAP32[((_opts_O)>>2)]=$312; + __label__ = 103; break; + case 86: + var $314=_options_witharg($2, $3, $argarg); + if ($314) { __label__ = 88; break; } else { __label__ = 87; break; } + case 87: + var $316=_printf(((STRING_TABLE.__str112565)|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)); + $1=0; + __label__ = 107; break; + case 88: + var $318=HEAP32[(($argarg)>>2)]; + HEAP32[((_opts_output)>>2)]=$318; + HEAP8[(_opts_output_wasset)]=1; + __label__ = 103; break; + case 89: + var $320=HEAP32[(($3)>>2)]; + var $321=(($320)|0); + var $322=HEAP32[(($321)>>2)]; + var $323=(($322+1)|0); + var $324=HEAP8[($323)]; + var $325=(($324 << 24) >> 24); + var $326=(($325)|0)==97; + var $327=$326 ? 1 : 2; + var $328=(($item+4)|0); + HEAP32[(($328)>>2)]=$327; + var $329=_options_witharg($2, $3, $argarg); + if ($329) { __label__ = 91; break; } else { __label__ = 90; break; } + case 90: + var $331=HEAP32[(($3)>>2)]; + var $332=(($331)|0); + var $333=HEAP32[(($332)>>2)]; + var $334=(($333+1)|0); + var $335=HEAP8[($334)]; + var $336=(($335 << 24) >> 24); + var $337=(($336)|0)==97; + var $338=$337 ? (((STRING_TABLE.__str114567)|0)) : (((STRING_TABLE.__str115568)|0)); + var $339=_printf(((STRING_TABLE.__str113566)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$338,tempInt)); + $1=0; + __label__ = 107; break; + case 91: + var $341=HEAP32[(($argarg)>>2)]; + var $342=(($item)|0); + HEAP32[(($342)>>2)]=$341; + var $343=(($item)|0); + var $344=HEAP32[(($343)>>2)]; + var $345=(($item+4)|0); + var $346=HEAP32[(($345)>>2)]; + var $347=_items_add($344, $346); + __label__ = 103; break; + case 92: + var $349=HEAP32[(($3)>>2)]; + var $350=(($349)|0); + var $351=HEAP32[(($350)>>2)]; + var $352=(($351+2)|0); + var $353=HEAP8[($352)]; + var $354=(($353 << 24) >> 24)!=0; + if ($354) { __label__ = 94; break; } else { __label__ = 93; break; } + case 93: + $argend=1; + __label__ = 103; break; + case 94: + var $357=HEAP32[(($3)>>2)]; + var $358=(($357)|0); + var $359=HEAP32[(($358)>>2)]; + var $360=(($359+2)|0); + var $361=_strcmp($360, ((STRING_TABLE.__str116569)|0)); + var $362=(($361)|0)!=0; + if ($362) { __label__ = 96; break; } else { __label__ = 95; break; } + case 95: + var $364=_usage(); + _exit(0); + throw "Reached an unreachable!" + case 96: + var $366=_options_long_witharg(((STRING_TABLE.__str117570)|0), $2, $3, $argarg); + if ($366) { __label__ = 97; break; } else { __label__ = 98; break; } + case 97: + var $368=HEAP32[(($argarg)>>2)]; + HEAP32[((_opts_output)>>2)]=$368; + HEAP8[(_opts_output_wasset)]=1; + __label__ = 99; break; + case 98: + var $370=HEAP32[(($3)>>2)]; + var $371=(($370)|0); + var $372=HEAP32[(($371)>>2)]; + var $373=_printf(((STRING_TABLE.__str118571)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$372,tempInt)); + $1=0; + __label__ = 107; break; + case 99: + __label__ = 100; break; + case 100: + __label__ = 101; break; + case 101: + __label__ = 103; break; + case 102: + var $378=HEAP32[(($3)>>2)]; + var $379=(($378)|0); + var $380=HEAP32[(($379)>>2)]; + var $381=_printf(((STRING_TABLE.__str118571)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$380,tempInt)); + $1=0; + __label__ = 107; break; + case 103: + __label__ = 105; break; + case 104: + var $384=HEAP32[(($3)>>2)]; + var $385=(($384)|0); + var $386=HEAP32[(($385)>>2)]; + var $387=(($item1)|0); + HEAP32[(($387)>>2)]=$386; + var $388=(($item1+4)|0); + HEAP32[(($388)>>2)]=0; + var $389=(($item1)|0); + var $390=HEAP32[(($389)>>2)]; + var $391=(($item1+4)|0); + var $392=HEAP32[(($391)>>2)]; + var $393=_items_add($390, $392); + __label__ = 105; break; + case 105: + __label__ = 3; break; + case 106: + $1=1; + __label__ = 107; break; + case 107: + var $397=$1; + STACKTOP = __stackBase__; + return $397; + default: assert(0, "bad label: " + __label__); + } +} +_options_parse["X"]=1; + +function _vec3_mulvv($a_0, $a_1, $a_2, $b_0, $b_1, $b_2) { + var __stackBase__ = STACKTOP; STACKTOP += 24; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $a=__stackBase__; + var $b=(__stackBase__)+(12); + var $1=(($a)|0); + HEAPF32[(($1)>>2)]=$a_0; + var $2=(($a+4)|0); + HEAPF32[(($2)>>2)]=$a_1; + var $3=(($a+8)|0); + HEAPF32[(($3)>>2)]=$a_2; + var $4=(($b)|0); + HEAPF32[(($4)>>2)]=$b_0; + var $5=(($b+4)|0); + HEAPF32[(($5)>>2)]=$b_1; + var $6=(($b+8)|0); + HEAPF32[(($6)>>2)]=$b_2; + var $7=(($a)|0); + var $8=HEAPF32[(($7)>>2)]; + var $9=(($b)|0); + var $10=HEAPF32[(($9)>>2)]; + var $11=($8)*($10); + var $12=(($a+4)|0); + var $13=HEAPF32[(($12)>>2)]; + var $14=(($b+4)|0); + var $15=HEAPF32[(($14)>>2)]; + var $16=($13)*($15); + var $17=($11)+($16); + var $18=(($a+8)|0); + var $19=HEAPF32[(($18)>>2)]; + var $20=(($b+8)|0); + var $21=HEAPF32[(($20)>>2)]; + var $22=($19)*($21); + var $23=($17)+($22); + STACKTOP = __stackBase__; + return $23; +} + + +function _options_long_witharg_all($optname, $argc_, $argv_, $out, $ds, $split) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + var $7; + var $argc; + var $argv; + var $len; + $2=$optname; + $3=$argc_; + $4=$argv_; + $5=$out; + $6=$ds; + var $8=(($split)&1); + $7=$8; + var $9=$3; + var $10=HEAP32[(($9)>>2)]; + $argc=$10; + var $11=$4; + var $12=HEAP32[(($11)>>2)]; + $argv=$12; + var $13=$2; + var $14=_strlen($13); + $len=$14; + var $15=$argv; + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$6; + var $19=(($17+$18)|0); + var $20=$2; + var $21=$len; + var $22=_strncmp($19, $20, $21); + var $23=(($22)|0)!=0; + if ($23) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=0; + __label__ = 10; break; + case 4: + var $26=$6; + var $27=$len; + var $28=((($26)+($27))|0); + var $29=$argv; + var $30=(($29)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31+$28)|0); + var $33=HEAP8[($32)]; + var $34=(($33 << 24) >> 24); + var $35=(($34)|0)==61; + if ($35) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $37=$argv; + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$6; + var $41=(($39+$40)|0); + var $42=$len; + var $43=(($41+$42)|0); + var $44=(($43+1)|0); + var $45=$5; + HEAP32[(($45)>>2)]=$44; + $1=1; + __label__ = 10; break; + case 6: + var $47=$7; + var $48=(($47) & 1); + if ($48) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $50=$argc; + var $51=$6; + var $52=(($50)|0) < (($51)|0); + if ($52) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + $1=0; + __label__ = 10; break; + case 9: + var $55=$argv; + var $56=(($55+4)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$5; + HEAP32[(($58)>>2)]=$57; + var $59=$3; + var $60=HEAP32[(($59)>>2)]; + var $61=((($60)-(1))|0); + HEAP32[(($59)>>2)]=$61; + var $62=$4; + var $63=HEAP32[(($62)>>2)]; + var $64=(($63+4)|0); + HEAP32[(($62)>>2)]=$64; + $1=1; + __label__ = 10; break; + case 10: + var $66=$1; + ; + return $66; + default: assert(0, "bad label: " + __label__); + } +} +_options_long_witharg_all["X"]=1; + +function _options_setflag_all($name, $on, $flags, $list, $listsize) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $6; + var $i; + var $lb; + $2=$name; + var $7=(($on)&1); + $3=$7; + $4=$flags; + $5=$list; + $6=$listsize; + $i=0; + __label__ = 3; break; + case 3: + var $9=$i; + var $10=$6; + var $11=(($9)>>>0) < (($10)>>>0); + if ($11) { __label__ = 4; break; } else { __label__ = 11; break; } + case 4: + var $13=$2; + var $14=$i; + var $15=$5; + var $16=(($15+($14<<3))|0); + var $17=(($16)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=_strcmp($13, $18); + var $20=(($19)|0)!=0; + if ($20) { __label__ = 9; break; } else { __label__ = 5; break; } + case 5: + var $22=$i; + var $23=$5; + var $24=(($23+($22<<3))|0); + var $25=(($24+4)|0); + var $26=HEAP32[(($25)>>2)]; + $lb=$26; + var $27=$3; + var $28=(($27) & 1); + if ($28) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $30=$lb; + var $31=1 << $30; + var $32=$4; + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$34 | $31; + HEAP32[(($33)>>2)]=$35; + __label__ = 8; break; + case 7: + var $37=$lb; + var $38=1 << $37; + var $39=$38 ^ -1; + var $40=$4; + var $41=(($40)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$42 & $39; + HEAP32[(($41)>>2)]=$43; + __label__ = 8; break; + case 8: + $1=1; + __label__ = 12; break; + case 9: + __label__ = 10; break; + case 10: + var $47=$i; + var $48=((($47)+(1))|0); + $i=$48; + __label__ = 3; break; + case 11: + $1=0; + __label__ = 12; break; + case 12: + var $51=$1; + ; + return $51; + default: assert(0, "bad label: " + __label__); + } +} +_options_setflag_all["X"]=1; + +function _parser_t_globals_add($self, $f_0, $f_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=$2; + var $6=(($5+12)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+16)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+16)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+16)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+16)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+16)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=((($28<<3))|0); + var $30=_util_memory_a($29, 42, ((STRING_TABLE.__str572)|0)); + var $31=$30; + $reall=$31; + var $32=$reall; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $36=$reall; + var $37=$36; + var $38=$2; + var $39=(($38+8)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + var $42=$2; + var $43=(($42+12)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44<<3))|0); + assert($45 % 1 === 0, 'memcpy given ' + $45 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $41, $45, 4); + var $46=$2; + var $47=(($46+8)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + _util_memory_d($49, 42, ((STRING_TABLE.__str572)|0)); + var $50=$reall; + var $51=$2; + var $52=(($51+8)|0); + HEAP32[(($52)>>2)]=$50; + __label__ = 9; break; + case 9: + var $54=$2; + var $55=(($54+12)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+8)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<3))|0); + var $62=$61; + var $63=$f; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($62)>>2)]=HEAP32[(($63)>>2)];HEAP32[((($62)+(4))>>2)]=HEAP32[((($63)+(4))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_globals_add["X"]=1; + +function _parser_t_fields_add($self, $f_0, $f_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=$2; + var $6=(($5+24)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+28)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+28)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+28)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+28)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+28)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=((($28<<3))|0); + var $30=_util_memory_a($29, 43, ((STRING_TABLE.__str572)|0)); + var $31=$30; + $reall=$31; + var $32=$reall; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $36=$reall; + var $37=$36; + var $38=$2; + var $39=(($38+20)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + var $42=$2; + var $43=(($42+24)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44<<3))|0); + assert($45 % 1 === 0, 'memcpy given ' + $45 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $41, $45, 4); + var $46=$2; + var $47=(($46+20)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + _util_memory_d($49, 43, ((STRING_TABLE.__str572)|0)); + var $50=$reall; + var $51=$2; + var $52=(($51+20)|0); + HEAP32[(($52)>>2)]=$50; + __label__ = 9; break; + case 9: + var $54=$2; + var $55=(($54+24)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+20)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<3))|0); + var $62=$61; + var $63=$f; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($62)>>2)]=HEAP32[(($63)>>2)];HEAP32[((($62)+(4))>>2)]=HEAP32[((($63)+(4))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_fields_add["X"]=1; + +function _parser_t_imm_float_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+48)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+52)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+52)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+52)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+52)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+52)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 44, ((STRING_TABLE.__str572)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+44)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+48)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+44)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 44, ((STRING_TABLE.__str572)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+44)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+48)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+44)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_imm_float_add["X"]=1; + +function _parser_t_imm_string_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+60)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+64)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+64)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+64)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+64)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+64)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 45, ((STRING_TABLE.__str572)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+56)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+60)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+56)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 45, ((STRING_TABLE.__str572)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+56)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+60)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+56)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_imm_string_add["X"]=1; + +function _parser_t_imm_vector_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+72)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+76)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+76)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+76)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+76)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+76)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 46, ((STRING_TABLE.__str572)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+68)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+72)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+68)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 46, ((STRING_TABLE.__str572)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+68)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+72)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+68)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_imm_vector_add["X"]=1; + +function _parser_t_locals_add($self, $f_0, $f_1) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=$2; + var $6=(($5+104)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+108)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+108)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+108)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+108)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+108)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=((($28<<3))|0); + var $30=_util_memory_a($29, 47, ((STRING_TABLE.__str572)|0)); + var $31=$30; + $reall=$31; + var $32=$reall; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $36=$reall; + var $37=$36; + var $38=$2; + var $39=(($38+100)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + var $42=$2; + var $43=(($42+104)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44<<3))|0); + assert($45 % 1 === 0, 'memcpy given ' + $45 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($37, $41, $45, 4); + var $46=$2; + var $47=(($46+100)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=$48; + _util_memory_d($49, 47, ((STRING_TABLE.__str572)|0)); + var $50=$reall; + var $51=$2; + var $52=(($51+100)|0); + HEAP32[(($52)>>2)]=$50; + __label__ = 9; break; + case 9: + var $54=$2; + var $55=(($54+104)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+100)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<3))|0); + var $62=$61; + var $63=$f; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($62)>>2)]=HEAP32[(($63)>>2)];HEAP32[((($62)+(4))>>2)]=HEAP32[((($63)+(4))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $65=$1; + STACKTOP = __stackBase__; + return $65; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_locals_add["X"]=1; + +function _parser_t_functions_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+36)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+40)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+40)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+40)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+40)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+40)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 48, ((STRING_TABLE.__str572)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+32)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+36)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+32)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 48, ((STRING_TABLE.__str572)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+32)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+36)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+32)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_parser_t_functions_add["X"]=1; + +function _vec3_add($agg_result, $a_0, $a_1, $a_2, $b_0, $b_1, $b_2) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $a=__stackBase__; + var $b=(__stackBase__)+(12); + var $out=(__stackBase__)+(24); + var $1=(($a)|0); + HEAPF32[(($1)>>2)]=$a_0; + var $2=(($a+4)|0); + HEAPF32[(($2)>>2)]=$a_1; + var $3=(($a+8)|0); + HEAPF32[(($3)>>2)]=$a_2; + var $4=(($b)|0); + HEAPF32[(($4)>>2)]=$b_0; + var $5=(($b+4)|0); + HEAPF32[(($5)>>2)]=$b_1; + var $6=(($b+8)|0); + HEAPF32[(($6)>>2)]=$b_2; + var $7=(($a)|0); + var $8=HEAPF32[(($7)>>2)]; + var $9=(($b)|0); + var $10=HEAPF32[(($9)>>2)]; + var $11=($8)+($10); + var $12=(($out)|0); + HEAPF32[(($12)>>2)]=$11; + var $13=(($a+4)|0); + var $14=HEAPF32[(($13)>>2)]; + var $15=(($b+4)|0); + var $16=HEAPF32[(($15)>>2)]; + var $17=($14)+($16); + var $18=(($out+4)|0); + HEAPF32[(($18)>>2)]=$17; + var $19=(($a+8)|0); + var $20=HEAPF32[(($19)>>2)]; + var $21=(($b+8)|0); + var $22=HEAPF32[(($21)>>2)]; + var $23=($20)+($22); + var $24=(($out+8)|0); + HEAPF32[(($24)>>2)]=$23; + var $25=$agg_result; + var $26=$out; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($25)>>2)]=HEAP32[(($26)>>2)];HEAP32[((($25)+(4))>>2)]=HEAP32[((($26)+(4))>>2)];HEAP32[((($25)+(8))>>2)]=HEAP32[((($26)+(8))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _vec3_sub($agg_result, $a_0, $a_1, $a_2, $b_0, $b_1, $b_2) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $a=__stackBase__; + var $b=(__stackBase__)+(12); + var $out=(__stackBase__)+(24); + var $1=(($a)|0); + HEAPF32[(($1)>>2)]=$a_0; + var $2=(($a+4)|0); + HEAPF32[(($2)>>2)]=$a_1; + var $3=(($a+8)|0); + HEAPF32[(($3)>>2)]=$a_2; + var $4=(($b)|0); + HEAPF32[(($4)>>2)]=$b_0; + var $5=(($b+4)|0); + HEAPF32[(($5)>>2)]=$b_1; + var $6=(($b+8)|0); + HEAPF32[(($6)>>2)]=$b_2; + var $7=(($a)|0); + var $8=HEAPF32[(($7)>>2)]; + var $9=(($b)|0); + var $10=HEAPF32[(($9)>>2)]; + var $11=($8)-($10); + var $12=(($out)|0); + HEAPF32[(($12)>>2)]=$11; + var $13=(($a+4)|0); + var $14=HEAPF32[(($13)>>2)]; + var $15=(($b+4)|0); + var $16=HEAPF32[(($15)>>2)]; + var $17=($14)-($16); + var $18=(($out+4)|0); + HEAPF32[(($18)>>2)]=$17; + var $19=(($a+8)|0); + var $20=HEAPF32[(($19)>>2)]; + var $21=(($b+8)|0); + var $22=HEAPF32[(($21)>>2)]; + var $23=($20)-($22); + var $24=(($out+8)|0); + HEAPF32[(($24)>>2)]=$23; + var $25=$agg_result; + var $26=$out; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($25)>>2)]=HEAP32[(($26)>>2)];HEAP32[((($25)+(4))>>2)]=HEAP32[((($26)+(4))>>2)];HEAP32[((($25)+(8))>>2)]=HEAP32[((($26)+(8))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _vec3_mulvf($agg_result, $a_0, $a_1, $a_2, $b) { + var __stackBase__ = STACKTOP; STACKTOP += 24; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $a=__stackBase__; + var $1; + var $out=(__stackBase__)+(12); + var $2=(($a)|0); + HEAPF32[(($2)>>2)]=$a_0; + var $3=(($a+4)|0); + HEAPF32[(($3)>>2)]=$a_1; + var $4=(($a+8)|0); + HEAPF32[(($4)>>2)]=$a_2; + $1=$b; + var $5=(($a)|0); + var $6=HEAPF32[(($5)>>2)]; + var $7=$1; + var $8=($6)*($7); + var $9=(($out)|0); + HEAPF32[(($9)>>2)]=$8; + var $10=(($a+4)|0); + var $11=HEAPF32[(($10)>>2)]; + var $12=$1; + var $13=($11)*($12); + var $14=(($out+4)|0); + HEAPF32[(($14)>>2)]=$13; + var $15=(($a+8)|0); + var $16=HEAPF32[(($15)>>2)]; + var $17=$1; + var $18=($16)*($17); + var $19=(($out+8)|0); + HEAPF32[(($19)>>2)]=$18; + var $20=$agg_result; + var $21=$out; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($20)>>2)]=HEAP32[(($21)>>2)];HEAP32[((($20)+(4))>>2)]=HEAP32[((($21)+(4))>>2)];HEAP32[((($20)+(8))>>2)]=HEAP32[((($21)+(8))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _parser_next($parser) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$parser; + var $3=$2; + var $4=(($3)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=_lex_do($5); + var $7=$2; + var $8=(($7+4)|0); + HEAP32[(($8)>>2)]=$6; + var $9=$2; + var $10=(($9+4)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($11)|0)==141; + if ($12) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 7; break; + case 4: + var $15=$2; + var $16=(($15+4)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0) >= 142; + if ($18) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $20=$2; + _parseerror($20, ((STRING_TABLE.__str1573)|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)); + $1=0; + __label__ = 7; break; + case 6: + $1=1; + __label__ = 7; break; + case 7: + var $23=$1; + STACKTOP = __stackBase__; + return $23; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parseerror($parser, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $2; + var $ap=__stackBase__; + $1=$parser; + $2=$fmt; + var $3=$1; + var $4=(($3+116)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=((($5)+(1))|0); + HEAP32[(($4)>>2)]=$6; + var $7=$ap; + HEAP32[(($7)>>2)]=arguments[_parseerror.length]; + var $8=$1; + var $9=(($8)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($10+292)|0); + var $12=(($11+28)|0); + var $13=(($12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=$1; + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17+292)|0); + var $19=(($18+28)|0); + var $20=(($19+4)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$2; + var $23=HEAP32[(($ap)>>2)]; + _vprintmsg(2, $14, $21, ((STRING_TABLE.__str4576)|0), $22, $23); + var $24=$ap; + ; + STACKTOP = __stackBase__; + return; +} + + +function _paramlist_t_p_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+8)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+8)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+8)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+8)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+8)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 312, ((STRING_TABLE.__str572)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+4)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 312, ((STRING_TABLE.__str572)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+4)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_paramlist_t_p_add["X"]=1; + +function _shunt_out_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $f; $f = STACKTOP;STACKTOP += 28;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($f)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($f)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)];HEAP32[((($f)+(8))>>2)]=HEAP32[(((tempParam)+(8))>>2)];HEAP32[((($f)+(12))>>2)]=HEAP32[(((tempParam)+(12))>>2)];HEAP32[((($f)+(16))>>2)]=HEAP32[(((tempParam)+(16))>>2)];HEAP32[((($f)+(20))>>2)]=HEAP32[(((tempParam)+(20))>>2)];HEAP32[((($f)+(24))>>2)]=HEAP32[(((tempParam)+(24))>>2)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+4)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+8)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+8)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+8)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+8)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+8)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26)*(28))|0); + var $28=_util_memory_a($27, 448, ((STRING_TABLE.__str572)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+4)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42)*(28))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4); + var $44=$2; + var $45=(($44)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 448, ((STRING_TABLE.__str572)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+4)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54)*(28))|0); + var $60=$59; + var $61=$f; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($60)>>2)]=HEAP32[(($61)>>2)];HEAP32[((($60)+(4))>>2)]=HEAP32[((($61)+(4))>>2)];HEAP32[((($60)+(8))>>2)]=HEAP32[((($61)+(8))>>2)];HEAP32[((($60)+(12))>>2)]=HEAP32[((($61)+(12))>>2)];HEAP32[((($60)+(16))>>2)]=HEAP32[((($61)+(16))>>2)];HEAP32[((($60)+(20))>>2)]=HEAP32[((($61)+(20))>>2)];HEAP32[((($60)+(24))>>2)]=HEAP32[((($61)+(24))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_shunt_out_add["X"]=1; + +function _shunt_ops_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var tempParam = $f; $f = STACKTOP;STACKTOP += 28;assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack");HEAP32[(($f)>>2)]=HEAP32[((tempParam)>>2)];HEAP32[((($f)+(4))>>2)]=HEAP32[(((tempParam)+(4))>>2)];HEAP32[((($f)+(8))>>2)]=HEAP32[(((tempParam)+(8))>>2)];HEAP32[((($f)+(12))>>2)]=HEAP32[(((tempParam)+(12))>>2)];HEAP32[((($f)+(16))>>2)]=HEAP32[(((tempParam)+(16))>>2)];HEAP32[((($f)+(20))>>2)]=HEAP32[(((tempParam)+(20))>>2)];HEAP32[((($f)+(24))>>2)]=HEAP32[(((tempParam)+(24))>>2)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+16)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+20)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+20)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+20)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+20)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+20)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26)*(28))|0); + var $28=_util_memory_a($27, 449, ((STRING_TABLE.__str572)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36+12)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+16)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42)*(28))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4); + var $44=$2; + var $45=(($44+12)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 449, ((STRING_TABLE.__str572)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49+12)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+16)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+12)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54)*(28))|0); + var $60=$59; + var $61=$f; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($60)>>2)]=HEAP32[(($61)>>2)];HEAP32[((($60)+(4))>>2)]=HEAP32[((($61)+(4))>>2)];HEAP32[((($60)+(8))>>2)]=HEAP32[((($61)+(8))>>2)];HEAP32[((($60)+(12))>>2)]=HEAP32[((($61)+(12))>>2)];HEAP32[((($60)+(16))>>2)]=HEAP32[((($61)+(16))>>2)];HEAP32[((($60)+(20))>>2)]=HEAP32[((($61)+(20))>>2)];HEAP32[((($60)+(24))>>2)]=HEAP32[((($61)+(24))>>2)]; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_shunt_ops_add["X"]=1; + +function _parser_init() { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2=_util_memory_a(124, 2835, ((STRING_TABLE.__str572)|0)); + var $3=$2; + HEAP32[((_parser)>>2)]=$3; + var $4=HEAP32[((_parser)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 5; break; + case 4: + var $8=HEAP32[((_parser)>>2)]; + var $9=$8; + for (var $$dest = $9>>2, $$stop = $$dest + 31; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + $1=1; + __label__ = 5; break; + case 5: + var $11=$1; + ; + return $11; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_compile() { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2=HEAP32[((_parser)>>2)]; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4+328)|0); + var $6=(($5)|0); + HEAP8[($6)]=1; + var $7=HEAP32[((_parser)>>2)]; + var $8=_parser_next($7); + if ($8) { __label__ = 3; break; } else { __label__ = 16; break; } + case 3: + __label__ = 4; break; + case 4: + var $11=HEAP32[((_parser)>>2)]; + var $12=(($11+4)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=141; + if ($14) { __label__ = 5; break; } else { var $21 = 0;__label__ = 6; break; } + case 5: + var $16=HEAP32[((_parser)>>2)]; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0) < 142; + var $21 = $19;__label__ = 6; break; + case 6: + var $21; + if ($21) { __label__ = 7; break; } else { __label__ = 15; break; } + case 7: + var $23=HEAP32[((_parser)>>2)]; + var $24=_parser_global_statement($23); + if ($24) { __label__ = 14; break; } else { __label__ = 8; break; } + case 8: + var $26=HEAP32[((_parser)>>2)]; + var $27=(($26+4)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)==141; + if ($29) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $31=HEAP32[((_parser)>>2)]; + _parseerror($31, ((STRING_TABLE.__str2574)|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)); + __label__ = 13; break; + case 10: + var $33=HEAP32[((_parser)>>2)]; + var $34=(($33+116)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)!=0; + if ($36) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $38=HEAP32[((_parser)>>2)]; + _parseerror($38, ((STRING_TABLE.__str3575)|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)); + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + var $41=HEAP32[((_parser)>>2)]; + var $42=(($41)|0); + var $43=HEAP32[(($42)>>2)]; + _lex_close($43); + var $44=HEAP32[((_parser)>>2)]; + var $45=(($44)|0); + HEAP32[(($45)>>2)]=0; + $1=0; + __label__ = 18; break; + case 14: + __label__ = 4; break; + case 15: + __label__ = 17; break; + case 16: + var $49=HEAP32[((_parser)>>2)]; + _parseerror($49, ((STRING_TABLE.__str4576)|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)); + var $50=HEAP32[((_parser)>>2)]; + var $51=(($50)|0); + var $52=HEAP32[(($51)>>2)]; + _lex_close($52); + var $53=HEAP32[((_parser)>>2)]; + var $54=(($53)|0); + HEAP32[(($54)>>2)]=0; + $1=0; + __label__ = 18; break; + case 17: + var $56=HEAP32[((_parser)>>2)]; + var $57=(($56)|0); + var $58=HEAP32[(($57)>>2)]; + _lex_close($58); + var $59=HEAP32[((_parser)>>2)]; + var $60=(($59)|0); + HEAP32[(($60)>>2)]=0; + var $61=HEAP32[((_parser)>>2)]; + var $62=(($61+116)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63)|0)!=0; + var $65=$64 ^ 1; + $1=$65; + __label__ = 18; break; + case 18: + var $67=$1; + STACKTOP = __stackBase__; + return $67; + default: assert(0, "bad label: " + __label__); + } +} +_parser_compile["X"]=1; + +function _parser_global_statement($parser) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$parser; + var $3=$2; + var $4=(($3+4)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)==130; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $8=$2; + var $9=(($8+4)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($10)|0)==46; + if ($11) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $13=$2; + var $14=_parse_variable($13, 0); + $1=$14; + __label__ = 15; break; + case 5: + var $16=$2; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18)|0)==132; + if ($19) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + $1=0; + __label__ = 15; break; + case 7: + var $22=$2; + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24)|0)==36; + if ($25) { __label__ = 8; break; } else { __label__ = 11; break; } + case 8: + var $27=$2; + var $28=_parser_next($27); + if ($28) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $30=$2; + _parseerror($30, ((STRING_TABLE.__str4576)|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)); + $1=0; + __label__ = 15; break; + case 10: + __label__ = 12; break; + case 11: + var $33=$2; + var $34=$2; + var $35=(($34)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36+292)|0); + var $38=(($37+4)|0); + var $39=HEAP32[(($38)>>2)]; + _parseerror($33, ((STRING_TABLE.__str29601)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$39,tempInt)); + $1=0; + __label__ = 15; break; + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + $1=1; + __label__ = 15; break; + case 15: + var $44=$1; + STACKTOP = __stackBase__; + return $44; + default: assert(0, "bad label: " + __label__); + } +} +_parser_global_statement["X"]=1; + +function _parser_compile_file($filename) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $2=$filename; + var $3=$2; + var $4=_lex_open($3); + var $5=HEAP32[((_parser)>>2)]; + var $6=(($5)|0); + HEAP32[(($6)>>2)]=$4; + var $7=HEAP32[((_parser)>>2)]; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $12=$2; + var $13=_printf(((STRING_TABLE.__str5577)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$12,tempInt)); + $1=0; + __label__ = 5; break; + case 4: + var $15=_parser_compile(); + $1=$15; + __label__ = 5; break; + case 5: + var $17=$1; + STACKTOP = __stackBase__; + return $17; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_compile_string($name, $str) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$name; + $3=$str; + var $4=$3; + var $5=$3; + var $6=_strlen($5); + var $7=$2; + var $8=_lex_open_string($4, $6, $7); + var $9=HEAP32[((_parser)>>2)]; + var $10=(($9)|0); + HEAP32[(($10)>>2)]=$8; + var $11=HEAP32[((_parser)>>2)]; + var $12=(($11)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $16=$2; + var $17=_printf(((STRING_TABLE.__str6578)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$16,tempInt)); + $1=0; + __label__ = 5; break; + case 4: + var $19=_parser_compile(); + $1=$19; + __label__ = 5; break; + case 5: + var $21=$1; + STACKTOP = __stackBase__; + return $21; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_cleanup() { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $i; + $i=0; + __label__ = 3; break; + case 3: + var $2=$i; + var $3=HEAP32[((_parser)>>2)]; + var $4=(($3+36)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($2)>>>0) < (($5)>>>0); + if ($6) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $8=$i; + var $9=HEAP32[((_parser)>>2)]; + var $10=(($9+32)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($11+($8<<2))|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$13; + var $15=$14; + var $16=(($15+8)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$i; + var $19=HEAP32[((_parser)>>2)]; + var $20=(($19+32)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21+($18<<2))|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$23; + FUNCTION_TABLE[$17]($24); + __label__ = 5; break; + case 5: + var $26=$i; + var $27=((($26)+(1))|0); + $i=$27; + __label__ = 3; break; + case 6: + $i=0; + __label__ = 7; break; + case 7: + var $30=$i; + var $31=HEAP32[((_parser)>>2)]; + var $32=(($31+72)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($30)>>>0) < (($33)>>>0); + if ($34) { __label__ = 8; break; } else { __label__ = 10; break; } + case 8: + var $36=$i; + var $37=HEAP32[((_parser)>>2)]; + var $38=(($37+68)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($39+($36<<2))|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$41; + var $43=$42; + var $44=(($43+8)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$i; + var $47=HEAP32[((_parser)>>2)]; + var $48=(($47+68)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=(($49+($46<<2))|0); + var $51=HEAP32[(($50)>>2)]; + var $52=$51; + FUNCTION_TABLE[$45]($52); + __label__ = 9; break; + case 9: + var $54=$i; + var $55=((($54)+(1))|0); + $i=$55; + __label__ = 7; break; + case 10: + $i=0; + __label__ = 11; break; + case 11: + var $58=$i; + var $59=HEAP32[((_parser)>>2)]; + var $60=(($59+60)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($58)>>>0) < (($61)>>>0); + if ($62) { __label__ = 12; break; } else { __label__ = 14; break; } + case 12: + var $64=$i; + var $65=HEAP32[((_parser)>>2)]; + var $66=(($65+56)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=(($67+($64<<2))|0); + var $69=HEAP32[(($68)>>2)]; + var $70=$69; + var $71=$70; + var $72=(($71+8)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=$i; + var $75=HEAP32[((_parser)>>2)]; + var $76=(($75+56)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=(($77+($74<<2))|0); + var $79=HEAP32[(($78)>>2)]; + var $80=$79; + FUNCTION_TABLE[$73]($80); + __label__ = 13; break; + case 13: + var $82=$i; + var $83=((($82)+(1))|0); + $i=$83; + __label__ = 11; break; + case 14: + $i=0; + __label__ = 15; break; + case 15: + var $86=$i; + var $87=HEAP32[((_parser)>>2)]; + var $88=(($87+48)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($86)>>>0) < (($89)>>>0); + if ($90) { __label__ = 16; break; } else { __label__ = 18; break; } + case 16: + var $92=$i; + var $93=HEAP32[((_parser)>>2)]; + var $94=(($93+44)|0); + var $95=HEAP32[(($94)>>2)]; + var $96=(($95+($92<<2))|0); + var $97=HEAP32[(($96)>>2)]; + var $98=$97; + var $99=$98; + var $100=(($99+8)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=$i; + var $103=HEAP32[((_parser)>>2)]; + var $104=(($103+44)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=(($105+($102<<2))|0); + var $107=HEAP32[(($106)>>2)]; + var $108=$107; + FUNCTION_TABLE[$101]($108); + __label__ = 17; break; + case 17: + var $110=$i; + var $111=((($110)+(1))|0); + $i=$111; + __label__ = 15; break; + case 18: + $i=0; + __label__ = 19; break; + case 19: + var $114=$i; + var $115=HEAP32[((_parser)>>2)]; + var $116=(($115+24)|0); + var $117=HEAP32[(($116)>>2)]; + var $118=(($114)>>>0) < (($117)>>>0); + if ($118) { __label__ = 20; break; } else { __label__ = 22; break; } + case 20: + var $120=$i; + var $121=HEAP32[((_parser)>>2)]; + var $122=(($121+20)|0); + var $123=HEAP32[(($122)>>2)]; + var $124=(($123+($120<<3))|0); + var $125=(($124+4)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=$126; + var $128=$127; + var $129=(($128+8)|0); + var $130=HEAP32[(($129)>>2)]; + var $131=$i; + var $132=HEAP32[((_parser)>>2)]; + var $133=(($132+20)|0); + var $134=HEAP32[(($133)>>2)]; + var $135=(($134+($131<<3))|0); + var $136=(($135+4)|0); + var $137=HEAP32[(($136)>>2)]; + var $138=$137; + FUNCTION_TABLE[$130]($138); + var $139=$i; + var $140=HEAP32[((_parser)>>2)]; + var $141=(($140+20)|0); + var $142=HEAP32[(($141)>>2)]; + var $143=(($142+($139<<3))|0); + var $144=(($143)|0); + var $145=HEAP32[(($144)>>2)]; + _util_memory_d($145, 2912, ((STRING_TABLE.__str572)|0)); + __label__ = 21; break; + case 21: + var $147=$i; + var $148=((($147)+(1))|0); + $i=$148; + __label__ = 19; break; + case 22: + $i=0; + __label__ = 23; break; + case 23: + var $151=$i; + var $152=HEAP32[((_parser)>>2)]; + var $153=(($152+12)|0); + var $154=HEAP32[(($153)>>2)]; + var $155=(($151)>>>0) < (($154)>>>0); + if ($155) { __label__ = 24; break; } else { __label__ = 26; break; } + case 24: + var $157=$i; + var $158=HEAP32[((_parser)>>2)]; + var $159=(($158+8)|0); + var $160=HEAP32[(($159)>>2)]; + var $161=(($160+($157<<3))|0); + var $162=(($161+4)|0); + var $163=HEAP32[(($162)>>2)]; + var $164=$163; + var $165=$164; + var $166=(($165+8)|0); + var $167=HEAP32[(($166)>>2)]; + var $168=$i; + var $169=HEAP32[((_parser)>>2)]; + var $170=(($169+8)|0); + var $171=HEAP32[(($170)>>2)]; + var $172=(($171+($168<<3))|0); + var $173=(($172+4)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=$174; + FUNCTION_TABLE[$167]($175); + var $176=$i; + var $177=HEAP32[((_parser)>>2)]; + var $178=(($177+8)|0); + var $179=HEAP32[(($178)>>2)]; + var $180=(($179+($176<<3))|0); + var $181=(($180)|0); + var $182=HEAP32[(($181)>>2)]; + _util_memory_d($182, 2916, ((STRING_TABLE.__str572)|0)); + __label__ = 25; break; + case 25: + var $184=$i; + var $185=((($184)+(1))|0); + $i=$185; + __label__ = 23; break; + case 26: + var $187=HEAP32[((_parser)>>2)]; + var $188=(($187+32)|0); + var $189=HEAP32[(($188)>>2)]; + var $190=(($189)|0)!=0; + if ($190) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + var $192=HEAP32[((_parser)>>2)]; + var $193=(($192+32)|0); + var $194=HEAP32[(($193)>>2)]; + var $195=$194; + _util_memory_d($195, 2918, ((STRING_TABLE.__str572)|0)); + __label__ = 28; break; + case 28: + var $197=HEAP32[((_parser)>>2)]; + var $198=(($197+32)|0); + HEAP32[(($198)>>2)]=0; + var $199=HEAP32[((_parser)>>2)]; + var $200=(($199+36)|0); + HEAP32[(($200)>>2)]=0; + var $201=HEAP32[((_parser)>>2)]; + var $202=(($201+40)|0); + HEAP32[(($202)>>2)]=0; + var $203=HEAP32[((_parser)>>2)]; + var $204=(($203+68)|0); + var $205=HEAP32[(($204)>>2)]; + var $206=(($205)|0)!=0; + if ($206) { __label__ = 29; break; } else { __label__ = 30; break; } + case 29: + var $208=HEAP32[((_parser)>>2)]; + var $209=(($208+68)|0); + var $210=HEAP32[(($209)>>2)]; + var $211=$210; + _util_memory_d($211, 2919, ((STRING_TABLE.__str572)|0)); + __label__ = 30; break; + case 30: + var $213=HEAP32[((_parser)>>2)]; + var $214=(($213+68)|0); + HEAP32[(($214)>>2)]=0; + var $215=HEAP32[((_parser)>>2)]; + var $216=(($215+72)|0); + HEAP32[(($216)>>2)]=0; + var $217=HEAP32[((_parser)>>2)]; + var $218=(($217+76)|0); + HEAP32[(($218)>>2)]=0; + var $219=HEAP32[((_parser)>>2)]; + var $220=(($219+56)|0); + var $221=HEAP32[(($220)>>2)]; + var $222=(($221)|0)!=0; + if ($222) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + var $224=HEAP32[((_parser)>>2)]; + var $225=(($224+56)|0); + var $226=HEAP32[(($225)>>2)]; + var $227=$226; + _util_memory_d($227, 2920, ((STRING_TABLE.__str572)|0)); + __label__ = 32; break; + case 32: + var $229=HEAP32[((_parser)>>2)]; + var $230=(($229+56)|0); + HEAP32[(($230)>>2)]=0; + var $231=HEAP32[((_parser)>>2)]; + var $232=(($231+60)|0); + HEAP32[(($232)>>2)]=0; + var $233=HEAP32[((_parser)>>2)]; + var $234=(($233+64)|0); + HEAP32[(($234)>>2)]=0; + var $235=HEAP32[((_parser)>>2)]; + var $236=(($235+44)|0); + var $237=HEAP32[(($236)>>2)]; + var $238=(($237)|0)!=0; + if ($238) { __label__ = 33; break; } else { __label__ = 34; break; } + case 33: + var $240=HEAP32[((_parser)>>2)]; + var $241=(($240+44)|0); + var $242=HEAP32[(($241)>>2)]; + var $243=$242; + _util_memory_d($243, 2921, ((STRING_TABLE.__str572)|0)); + __label__ = 34; break; + case 34: + var $245=HEAP32[((_parser)>>2)]; + var $246=(($245+44)|0); + HEAP32[(($246)>>2)]=0; + var $247=HEAP32[((_parser)>>2)]; + var $248=(($247+48)|0); + HEAP32[(($248)>>2)]=0; + var $249=HEAP32[((_parser)>>2)]; + var $250=(($249+52)|0); + HEAP32[(($250)>>2)]=0; + var $251=HEAP32[((_parser)>>2)]; + var $252=(($251+8)|0); + var $253=HEAP32[(($252)>>2)]; + var $254=(($253)|0)!=0; + if ($254) { __label__ = 35; break; } else { __label__ = 36; break; } + case 35: + var $256=HEAP32[((_parser)>>2)]; + var $257=(($256+8)|0); + var $258=HEAP32[(($257)>>2)]; + var $259=$258; + _util_memory_d($259, 2922, ((STRING_TABLE.__str572)|0)); + __label__ = 36; break; + case 36: + var $261=HEAP32[((_parser)>>2)]; + var $262=(($261+8)|0); + HEAP32[(($262)>>2)]=0; + var $263=HEAP32[((_parser)>>2)]; + var $264=(($263+12)|0); + HEAP32[(($264)>>2)]=0; + var $265=HEAP32[((_parser)>>2)]; + var $266=(($265+16)|0); + HEAP32[(($266)>>2)]=0; + var $267=HEAP32[((_parser)>>2)]; + var $268=(($267+20)|0); + var $269=HEAP32[(($268)>>2)]; + var $270=(($269)|0)!=0; + if ($270) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + var $272=HEAP32[((_parser)>>2)]; + var $273=(($272+20)|0); + var $274=HEAP32[(($273)>>2)]; + var $275=$274; + _util_memory_d($275, 2923, ((STRING_TABLE.__str572)|0)); + __label__ = 38; break; + case 38: + var $277=HEAP32[((_parser)>>2)]; + var $278=(($277+20)|0); + HEAP32[(($278)>>2)]=0; + var $279=HEAP32[((_parser)>>2)]; + var $280=(($279+24)|0); + HEAP32[(($280)>>2)]=0; + var $281=HEAP32[((_parser)>>2)]; + var $282=(($281+28)|0); + HEAP32[(($282)>>2)]=0; + var $283=HEAP32[((_parser)>>2)]; + var $284=(($283+100)|0); + var $285=HEAP32[(($284)>>2)]; + var $286=(($285)|0)!=0; + if ($286) { __label__ = 39; break; } else { __label__ = 40; break; } + case 39: + var $288=HEAP32[((_parser)>>2)]; + var $289=(($288+100)|0); + var $290=HEAP32[(($289)>>2)]; + var $291=$290; + _util_memory_d($291, 2924, ((STRING_TABLE.__str572)|0)); + __label__ = 40; break; + case 40: + var $293=HEAP32[((_parser)>>2)]; + var $294=(($293+100)|0); + HEAP32[(($294)>>2)]=0; + var $295=HEAP32[((_parser)>>2)]; + var $296=(($295+104)|0); + HEAP32[(($296)>>2)]=0; + var $297=HEAP32[((_parser)>>2)]; + var $298=(($297+108)|0); + HEAP32[(($298)>>2)]=0; + var $299=HEAP32[((_parser)>>2)]; + var $300=$299; + _util_memory_d($300, 2926, ((STRING_TABLE.__str572)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_parser_cleanup["X"]=1; + +function _progdefs_crc_file($str) { + ; + var __label__; + + var $1; + $1=$str; + ; + return; +} + + +function _parser_finish($output) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $i; + var $ir; + var $retval; + var $field; + var $isconst; + var $ifld; + var $subtype; + var $asvalue; + $2=$output; + $retval=1; + var $3=HEAP32[((_parser)>>2)]; + var $4=(($3+116)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 70; break; } else { __label__ = 3; break; } + case 3: + var $8=_ir_builder_new(((STRING_TABLE.__str7579)|0)); + $ir=$8; + var $9=$ir; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=_printf(((STRING_TABLE.__str8580)|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)); + $1=0; + __label__ = 71; break; + case 5: + $i=0; + __label__ = 6; break; + case 6: + var $15=$i; + var $16=HEAP32[((_parser)>>2)]; + var $17=(($16+24)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($15)>>>0) < (($18)>>>0); + if ($19) { __label__ = 7; break; } else { __label__ = 20; break; } + case 7: + var $21=$i; + var $22=HEAP32[((_parser)>>2)]; + var $23=(($22+20)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<3))|0); + var $26=(($25+4)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=$27; + var $29=(($28+12)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)==2; + if ($31) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + __label__ = 19; break; + case 9: + var $34=$i; + var $35=HEAP32[((_parser)>>2)]; + var $36=(($35+20)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37+($34<<3))|0); + var $39=(($38+4)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$40; + $field=$41; + var $42=$field; + var $43=(($42+60)|0); + var $44=HEAP8[($43)]; + var $45=(($44) & 1); + var $46=(($45)&1); + $isconst=$46; + var $47=$field; + var $48=(($47+60)|0); + HEAP8[($48)]=0; + var $49=$field; + var $50=$ir; + var $51=_ast_global_codegen($49, $50); + if ($51) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $53=$field; + var $54=(($53+56)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=_printf(((STRING_TABLE.__str9581)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$55,tempInt)); + var $57=$ir; + _ir_builder_delete($57); + $1=0; + __label__ = 71; break; + case 11: + var $59=$isconst; + var $60=(($59) & 1); + if ($60) { __label__ = 12; break; } else { __label__ = 18; break; } + case 12: + var $62=$field; + var $63=(($62+60)|0); + HEAP8[($63)]=1; + var $64=$field; + var $65=(($64)|0); + var $66=(($65+28)|0); + var $67=HEAP32[(($66)>>2)]; + $subtype=$67; + var $68=$ir; + var $69=$field; + var $70=(($69+56)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$subtype; + var $73=$72; + var $74=(($73+24)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=_ir_builder_create_field($68, $71, $75); + $ifld=$76; + var $77=$subtype; + var $78=$77; + var $79=(($78+24)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=(($80)|0)==5; + if ($81) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $83=$subtype; + var $84=$83; + var $85=(($84+28)|0); + var $86=HEAP32[(($85)>>2)]; + var $87=$86; + var $88=(($87+24)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=$ifld; + var $91=(($90+20)|0); + HEAP32[(($91)>>2)]=$89; + __label__ = 17; break; + case 14: + var $93=$subtype; + var $94=$93; + var $95=(($94+24)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=(($96)|0)==6; + if ($97) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $99=$subtype; + var $100=$99; + var $101=(($100+28)|0); + var $102=HEAP32[(($101)>>2)]; + var $103=$102; + var $104=(($103+24)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=$ifld; + var $107=(($106+24)|0); + HEAP32[(($107)>>2)]=$105; + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + var $110=$field; + var $111=(($110+80)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=$ifld; + var $114=_ir_value_set_field($112, $113); + var $115=$114 ^ 1; + var $116=(($115)&1); + __label__ = 18; break; + case 18: + __label__ = 19; break; + case 19: + var $119=$i; + var $120=((($119)+(1))|0); + $i=$120; + __label__ = 6; break; + case 20: + $i=0; + __label__ = 21; break; + case 21: + var $123=$i; + var $124=HEAP32[((_parser)>>2)]; + var $125=(($124+12)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=(($123)>>>0) < (($126)>>>0); + if ($127) { __label__ = 22; break; } else { __label__ = 37; break; } + case 22: + var $129=$i; + var $130=HEAP32[((_parser)>>2)]; + var $131=(($130+8)|0); + var $132=HEAP32[(($131)>>2)]; + var $133=(($132+($129<<3))|0); + var $134=(($133+4)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=$135; + var $137=(($136+12)|0); + var $138=HEAP32[(($137)>>2)]; + var $139=(($138)|0)==2; + if ($139) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + __label__ = 36; break; + case 24: + var $142=$i; + var $143=HEAP32[((_parser)>>2)]; + var $144=(($143+8)|0); + var $145=HEAP32[(($144)>>2)]; + var $146=(($145+($142<<3))|0); + var $147=(($146+4)|0); + var $148=HEAP32[(($147)>>2)]; + var $149=$148; + $asvalue=$149; + var $150=$asvalue; + var $151=(($150+76)|0); + var $152=HEAP32[(($151)>>2)]; + var $153=(($152)|0)!=0; + if ($153) { __label__ = 33; break; } else { __label__ = 25; break; } + case 25: + var $155=$asvalue; + var $156=(($155+60)|0); + var $157=HEAP8[($156)]; + var $158=(($157) & 1); + if ($158) { __label__ = 33; break; } else { __label__ = 26; break; } + case 26: + var $160=$asvalue; + var $161=(($160)|0); + var $162=(($161+24)|0); + var $163=HEAP32[(($162)>>2)]; + var $164=(($163)|0)!=6; + if ($164) { __label__ = 27; break; } else { __label__ = 33; break; } + case 27: + var $166=$asvalue; + var $167=(($166+56)|0); + var $168=HEAP32[(($167)>>2)]; + var $169=_strcmp($168, ((STRING_TABLE.__str10582)|0)); + var $170=(($169)|0)!=0; + if ($170) { __label__ = 28; break; } else { __label__ = 32; break; } + case 28: + var $172=$asvalue; + var $173=(($172+56)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=_strcmp($174, ((STRING_TABLE.__str11583)|0)); + var $176=(($175)|0)!=0; + if ($176) { __label__ = 29; break; } else { __label__ = 32; break; } + case 29: + var $178=$retval; + var $179=(($178) & 1); + if ($179) { __label__ = 30; break; } else { var $194 = 0;__label__ = 31; break; } + case 30: + var $181=$asvalue; + var $182=$181; + var $183=(($182)|0); + var $184=$asvalue; + var $185=(($184+56)|0); + var $186=HEAP32[(($185)>>2)]; + var $187=(($183)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=(($183+4)|0); + var $190=HEAP32[(($189)>>2)]; + var $191=_genwarning($188, $190, 1, ((STRING_TABLE.__str12584)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$186,tempInt)); + var $192=$191 ^ 1; + var $194 = $192;__label__ = 31; break; + case 31: + var $194; + var $195=(($194)&1); + $retval=$195; + __label__ = 32; break; + case 32: + __label__ = 33; break; + case 33: + var $198=$asvalue; + var $199=$ir; + var $200=_ast_global_codegen($198, $199); + if ($200) { __label__ = 35; break; } else { __label__ = 34; break; } + case 34: + var $202=$i; + var $203=HEAP32[((_parser)>>2)]; + var $204=(($203+8)|0); + var $205=HEAP32[(($204)>>2)]; + var $206=(($205+($202<<3))|0); + var $207=(($206)|0); + var $208=HEAP32[(($207)>>2)]; + var $209=_printf(((STRING_TABLE.__str13585)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$208,tempInt)); + var $210=$ir; + _ir_builder_delete($210); + $1=0; + __label__ = 71; break; + case 35: + __label__ = 36; break; + case 36: + var $213=$i; + var $214=((($213)+(1))|0); + $i=$214; + __label__ = 21; break; + case 37: + $i=0; + __label__ = 38; break; + case 38: + var $217=$i; + var $218=HEAP32[((_parser)>>2)]; + var $219=(($218+48)|0); + var $220=HEAP32[(($219)>>2)]; + var $221=(($217)>>>0) < (($220)>>>0); + if ($221) { __label__ = 39; break; } else { __label__ = 43; break; } + case 39: + var $223=$i; + var $224=HEAP32[((_parser)>>2)]; + var $225=(($224+44)|0); + var $226=HEAP32[(($225)>>2)]; + var $227=(($226+($223<<2))|0); + var $228=HEAP32[(($227)>>2)]; + var $229=$ir; + var $230=_ast_global_codegen($228, $229); + if ($230) { __label__ = 41; break; } else { __label__ = 40; break; } + case 40: + var $232=$i; + var $233=HEAP32[((_parser)>>2)]; + var $234=(($233+44)|0); + var $235=HEAP32[(($234)>>2)]; + var $236=(($235+($232<<2))|0); + var $237=HEAP32[(($236)>>2)]; + var $238=(($237+56)|0); + var $239=HEAP32[(($238)>>2)]; + var $240=_printf(((STRING_TABLE.__str13585)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$239,tempInt)); + var $241=$ir; + _ir_builder_delete($241); + $1=0; + __label__ = 71; break; + case 41: + __label__ = 42; break; + case 42: + var $244=$i; + var $245=((($244)+(1))|0); + $i=$245; + __label__ = 38; break; + case 43: + $i=0; + __label__ = 44; break; + case 44: + var $248=$i; + var $249=HEAP32[((_parser)>>2)]; + var $250=(($249+60)|0); + var $251=HEAP32[(($250)>>2)]; + var $252=(($248)>>>0) < (($251)>>>0); + if ($252) { __label__ = 45; break; } else { __label__ = 49; break; } + case 45: + var $254=$i; + var $255=HEAP32[((_parser)>>2)]; + var $256=(($255+56)|0); + var $257=HEAP32[(($256)>>2)]; + var $258=(($257+($254<<2))|0); + var $259=HEAP32[(($258)>>2)]; + var $260=$ir; + var $261=_ast_global_codegen($259, $260); + if ($261) { __label__ = 47; break; } else { __label__ = 46; break; } + case 46: + var $263=$i; + var $264=HEAP32[((_parser)>>2)]; + var $265=(($264+56)|0); + var $266=HEAP32[(($265)>>2)]; + var $267=(($266+($263<<2))|0); + var $268=HEAP32[(($267)>>2)]; + var $269=(($268+56)|0); + var $270=HEAP32[(($269)>>2)]; + var $271=_printf(((STRING_TABLE.__str13585)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$270,tempInt)); + var $272=$ir; + _ir_builder_delete($272); + $1=0; + __label__ = 71; break; + case 47: + __label__ = 48; break; + case 48: + var $275=$i; + var $276=((($275)+(1))|0); + $i=$276; + __label__ = 44; break; + case 49: + $i=0; + __label__ = 50; break; + case 50: + var $279=$i; + var $280=HEAP32[((_parser)>>2)]; + var $281=(($280+72)|0); + var $282=HEAP32[(($281)>>2)]; + var $283=(($279)>>>0) < (($282)>>>0); + if ($283) { __label__ = 51; break; } else { __label__ = 55; break; } + case 51: + var $285=$i; + var $286=HEAP32[((_parser)>>2)]; + var $287=(($286+68)|0); + var $288=HEAP32[(($287)>>2)]; + var $289=(($288+($285<<2))|0); + var $290=HEAP32[(($289)>>2)]; + var $291=$ir; + var $292=_ast_global_codegen($290, $291); + if ($292) { __label__ = 53; break; } else { __label__ = 52; break; } + case 52: + var $294=$i; + var $295=HEAP32[((_parser)>>2)]; + var $296=(($295+68)|0); + var $297=HEAP32[(($296)>>2)]; + var $298=(($297+($294<<2))|0); + var $299=HEAP32[(($298)>>2)]; + var $300=(($299+56)|0); + var $301=HEAP32[(($300)>>2)]; + var $302=_printf(((STRING_TABLE.__str13585)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$301,tempInt)); + var $303=$ir; + _ir_builder_delete($303); + $1=0; + __label__ = 71; break; + case 53: + __label__ = 54; break; + case 54: + var $306=$i; + var $307=((($306)+(1))|0); + $i=$307; + __label__ = 50; break; + case 55: + $i=0; + __label__ = 56; break; + case 56: + var $310=$i; + var $311=HEAP32[((_parser)>>2)]; + var $312=(($311+36)|0); + var $313=HEAP32[(($312)>>2)]; + var $314=(($310)>>>0) < (($313)>>>0); + if ($314) { __label__ = 57; break; } else { __label__ = 63; break; } + case 57: + var $316=$i; + var $317=HEAP32[((_parser)>>2)]; + var $318=(($317+32)|0); + var $319=HEAP32[(($318)>>2)]; + var $320=(($319+($316<<2))|0); + var $321=HEAP32[(($320)>>2)]; + var $322=$ir; + var $323=_ast_function_codegen($321, $322); + if ($323) { __label__ = 59; break; } else { __label__ = 58; break; } + case 58: + var $325=$i; + var $326=HEAP32[((_parser)>>2)]; + var $327=(($326+32)|0); + var $328=HEAP32[(($327)>>2)]; + var $329=(($328+($325<<2))|0); + var $330=HEAP32[(($329)>>2)]; + var $331=(($330+24)|0); + var $332=HEAP32[(($331)>>2)]; + var $333=_printf(((STRING_TABLE.__str14586)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$332,tempInt)); + var $334=$ir; + _ir_builder_delete($334); + $1=0; + __label__ = 71; break; + case 59: + var $336=$i; + var $337=HEAP32[((_parser)>>2)]; + var $338=(($337+32)|0); + var $339=HEAP32[(($338)>>2)]; + var $340=(($339+($336<<2))|0); + var $341=HEAP32[(($340)>>2)]; + var $342=(($341+32)|0); + var $343=HEAP32[(($342)>>2)]; + var $344=_ir_function_finalize($343); + if ($344) { __label__ = 61; break; } else { __label__ = 60; break; } + case 60: + var $346=$i; + var $347=HEAP32[((_parser)>>2)]; + var $348=(($347+32)|0); + var $349=HEAP32[(($348)>>2)]; + var $350=(($349+($346<<2))|0); + var $351=HEAP32[(($350)>>2)]; + var $352=(($351+24)|0); + var $353=HEAP32[(($352)>>2)]; + var $354=_printf(((STRING_TABLE.__str15587)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$353,tempInt)); + var $355=$ir; + _ir_builder_delete($355); + $1=0; + __label__ = 71; break; + case 61: + __label__ = 62; break; + case 62: + var $358=$i; + var $359=((($358)+(1))|0); + $i=$359; + __label__ = 56; break; + case 63: + var $361=$retval; + var $362=(($361) & 1); + if ($362) { __label__ = 64; break; } else { __label__ = 69; break; } + case 64: + var $364=HEAP8[(_opts_dump)]; + var $365=(($364) & 1); + if ($365) { __label__ = 65; break; } else { __label__ = 66; break; } + case 65: + var $367=$ir; + _ir_builder_dump($367, 34); + __label__ = 66; break; + case 66: + var $369=HEAP32[((_parser)>>2)]; + _generate_checksum($369); + var $370=$ir; + var $371=$2; + var $372=_ir_builder_generate($370, $371); + if ($372) { __label__ = 68; break; } else { __label__ = 67; break; } + case 67: + var $374=_printf(((STRING_TABLE.__str16588)|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)); + var $375=$ir; + _ir_builder_delete($375); + $1=0; + __label__ = 71; break; + case 68: + __label__ = 69; break; + case 69: + var $378=$ir; + _ir_builder_delete($378); + var $379=$retval; + var $380=(($379) & 1); + $1=$380; + __label__ = 71; break; + case 70: + var $382=_printf(((STRING_TABLE.__str17589)|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)); + $1=0; + __label__ = 71; break; + case 71: + var $384=$1; + STACKTOP = __stackBase__; + return $384; + default: assert(0, "bad label: " + __label__); + } +} +_parser_finish["X"]=1; + +function _genwarning($ctx_0, $ctx_1, $warntype, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $ctx=__stackBase__; + var $2; + var $3; + var $ap=(__stackBase__)+(8); + var $lvl; + var $4=(($ctx)|0); + HEAP32[(($4)>>2)]=$ctx_0; + var $5=(($ctx+4)|0); + HEAP32[(($5)>>2)]=$ctx_1; + $2=$warntype; + $3=$fmt; + $lvl=1; + var $6=$2; + var $7=((((($6)|0))/(32))&-1); + var $8=((_opts_warn+($7<<2))|0); + var $9=HEAP32[(($8)>>2)]; + var $10=$2; + var $11=((($10)|0))%(32); + var $12=1 << $11; + var $13=$9 & $12; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $17=HEAP8[(_opts_werror)]; + var $18=(($17) & 1); + if ($18) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $lvl=2; + __label__ = 6; break; + case 6: + var $21=$ap; + HEAP32[(($21)>>2)]=arguments[_genwarning.length]; + var $22=$lvl; + var $23=(($ctx)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($ctx+4)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$3; + var $28=HEAP32[(($ap)>>2)]; + _vprintmsg($22, $24, $26, ((STRING_TABLE.__str28600)|0), $27, $28); + var $29=$ap; + ; + var $30=HEAP8[(_opts_werror)]; + var $31=(($30) & 1); + $1=$31; + __label__ = 7; break; + case 7: + var $33=$1; + STACKTOP = __stackBase__; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _generate_checksum($parser) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $crc; + var $i; + $1=$parser; + $crc=-1; + var $2=$crc; + var $3=_progdefs_crc_both($2, ((STRING_TABLE.__str18590)|0)); + $crc=$3; + var $4=$crc; + var $5=_progdefs_crc_sum($4, ((STRING_TABLE.__str19591)|0)); + $crc=$5; + $i=0; + __label__ = 3; break; + case 3: + var $7=$i; + var $8=$1; + var $9=(($8+88)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)>>>0) < (($10)>>>0); + if ($11) { __label__ = 4; break; } else { __label__ = 14; break; } + case 4: + var $13=$i; + var $14=$1; + var $15=(($14+8)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16+($13<<3))|0); + var $18=(($17+4)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=$19; + var $21=(($20+12)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=(($22)|0)==2; + if ($23) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + __label__ = 13; break; + case 6: + var $26=$i; + var $27=$1; + var $28=(($27+8)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<3))|0); + var $31=(($30+4)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$32; + var $34=(($33+24)|0); + var $35=HEAP32[(($34)>>2)]; + if ((($35)|0) == 2) { + __label__ = 7; break; + } + else if ((($35)|0) == 3) { + __label__ = 8; break; + } + else if ((($35)|0) == 1) { + __label__ = 9; break; + } + else if ((($35)|0) == 6) { + __label__ = 10; break; + } + else { + __label__ = 11; break; + } + + case 7: + var $37=$crc; + var $38=_progdefs_crc_both($37, ((STRING_TABLE.__str20592)|0)); + $crc=$38; + __label__ = 12; break; + case 8: + var $40=$crc; + var $41=_progdefs_crc_both($40, ((STRING_TABLE.__str21593)|0)); + $crc=$41; + __label__ = 12; break; + case 9: + var $43=$crc; + var $44=_progdefs_crc_both($43, ((STRING_TABLE.__str22594)|0)); + $crc=$44; + __label__ = 12; break; + case 10: + var $46=$crc; + var $47=_progdefs_crc_both($46, ((STRING_TABLE.__str23595)|0)); + $crc=$47; + __label__ = 12; break; + case 11: + var $49=$crc; + var $50=_progdefs_crc_both($49, ((STRING_TABLE.__str24596)|0)); + $crc=$50; + __label__ = 12; break; + case 12: + var $52=$crc; + var $53=$i; + var $54=$1; + var $55=(($54+8)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+($53<<3))|0); + var $58=(($57)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=_progdefs_crc_both($52, $59); + $crc=$60; + var $61=$crc; + var $62=_progdefs_crc_both($61, ((STRING_TABLE.__str25597)|0)); + $crc=$62; + __label__ = 13; break; + case 13: + var $64=$i; + var $65=((($64)+(1))|0); + $i=$65; + __label__ = 3; break; + case 14: + var $67=$crc; + var $68=_progdefs_crc_both($67, ((STRING_TABLE.__str26598)|0)); + $crc=$68; + $i=0; + __label__ = 15; break; + case 15: + var $70=$i; + var $71=$1; + var $72=(($71+92)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=(($70)>>>0) < (($73)>>>0); + if ($74) { __label__ = 16; break; } else { __label__ = 26; break; } + case 16: + var $76=$i; + var $77=$1; + var $78=(($77+20)|0); + var $79=HEAP32[(($78)>>2)]; + var $80=(($79+($76<<3))|0); + var $81=(($80+4)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=$82; + var $84=(($83+12)|0); + var $85=HEAP32[(($84)>>2)]; + var $86=(($85)|0)==2; + if ($86) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + __label__ = 25; break; + case 18: + var $89=$i; + var $90=$1; + var $91=(($90+20)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($92+($89<<3))|0); + var $94=(($93+4)|0); + var $95=HEAP32[(($94)>>2)]; + var $96=$95; + var $97=(($96+28)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=$98; + var $100=(($99+24)|0); + var $101=HEAP32[(($100)>>2)]; + if ((($101)|0) == 2) { + __label__ = 19; break; + } + else if ((($101)|0) == 3) { + __label__ = 20; break; + } + else if ((($101)|0) == 1) { + __label__ = 21; break; + } + else if ((($101)|0) == 6) { + __label__ = 22; break; + } + else { + __label__ = 23; break; + } + + case 19: + var $103=$crc; + var $104=_progdefs_crc_both($103, ((STRING_TABLE.__str20592)|0)); + $crc=$104; + __label__ = 24; break; + case 20: + var $106=$crc; + var $107=_progdefs_crc_both($106, ((STRING_TABLE.__str21593)|0)); + $crc=$107; + __label__ = 24; break; + case 21: + var $109=$crc; + var $110=_progdefs_crc_both($109, ((STRING_TABLE.__str22594)|0)); + $crc=$110; + __label__ = 24; break; + case 22: + var $112=$crc; + var $113=_progdefs_crc_both($112, ((STRING_TABLE.__str23595)|0)); + $crc=$113; + __label__ = 24; break; + case 23: + var $115=$crc; + var $116=_progdefs_crc_both($115, ((STRING_TABLE.__str24596)|0)); + $crc=$116; + __label__ = 24; break; + case 24: + var $118=$crc; + var $119=$i; + var $120=$1; + var $121=(($120+20)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=(($122+($119<<3))|0); + var $124=(($123)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=_progdefs_crc_both($118, $125); + $crc=$126; + var $127=$crc; + var $128=_progdefs_crc_both($127, ((STRING_TABLE.__str25597)|0)); + $crc=$128; + __label__ = 25; break; + case 25: + var $130=$i; + var $131=((($130)+(1))|0); + $i=$131; + __label__ = 15; break; + case 26: + var $133=$crc; + var $134=_progdefs_crc_both($133, ((STRING_TABLE.__str27599)|0)); + $crc=$134; + var $135=$crc; + HEAP16[((_code_crc)>>1)]=$135; + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_generate_checksum["X"]=1; + +function _progdefs_crc_both($old, $str) { + ; + var __label__; + + var $1; + var $2; + $1=$old; + $2=$str; + var $3=$1; + var $4=$2; + var $5=_progdefs_crc_sum($3, $4); + $1=$5; + var $6=$2; + _progdefs_crc_file($6); + var $7=$1; + ; + return $7; +} + + +function _progdefs_crc_sum($old, $str) { + ; + var __label__; + + var $1; + var $2; + $1=$old; + $2=$str; + var $3=$1; + var $4=$2; + var $5=$2; + var $6=_strlen($5); + var $7=_util_crc16($3, $4, $6); + ; + return $7; +} + + +function _parse_variable($parser, $localblock) { + var __stackBase__ = STACKTOP; STACKTOP += 52; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $isfunc=__stackBase__; + var $ctx=(__stackBase__)+(4); + var $var; + var $fld; + var $cleanvar; + var $varent=(__stackBase__)+(12); + var $ve=(__stackBase__)+(20); + var $olddecl; + var $typevar; + var $hadproto; + var $isparam=(__stackBase__)+(44); + var $retval; + var $isfield; + var $basetype; + var $was_end; + var $fval; + var $proto; + var $dummy=(__stackBase__)+(48); + var $param; + var $tmp; + var $e; + var $func; + var $cexp; + var $cval; + $2=$parser; + $3=$localblock; + HEAP8[($isfunc)]=0; + $var=0; + $fld=0; + $cleanvar=0; + $retval=1; + $isfield=0; + var $4=$2; + var $5=(($4+4)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)==46; + if ($7) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + $isfield=1; + var $9=$2; + var $10=_parser_next($9); + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $12=$2; + _parseerror($12, ((STRING_TABLE.__str30602)|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)); + $1=0; + __label__ = 229; break; + case 5: + __label__ = 6; break; + case 6: + var $15=$2; + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17+292)|0); + var $19=(($18+16)|0); + var $20=$19; + var $21=HEAP32[(($20)>>2)]; + $basetype=$21; + var $22=$2; + var $23=_parser_next($22); + if ($23) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $25=$2; + _parseerror($25, ((STRING_TABLE.__str31603)|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)); + $1=0; + __label__ = 229; break; + case 8: + var $27=$2; + var $28=$basetype; + var $29=_parse_type($27, $28, $isfunc); + $typevar=$29; + var $30=$typevar; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + $1=0; + __label__ = 229; break; + case 10: + __label__ = 11; break; + case 11: + $hadproto=0; + $olddecl=0; + HEAP8[($isparam)]=0; + var $35=(($varent)|0); + HEAP32[(($35)>>2)]=0; + var $36=(($ve+16)|0); + var $37=(($36)|0); + HEAP32[(($37)>>2)]=0; + var $38=(($ve+8)|0); + var $39=(($38)|0); + HEAP32[(($39)>>2)]=0; + var $40=(($ve)|0); + var $41=(($40)|0); + HEAP32[(($41)>>2)]=0; + var $42=(($ve+16)|0); + var $43=(($42+4)|0); + HEAP32[(($43)>>2)]=0; + var $44=(($ve+8)|0); + var $45=(($44+4)|0); + HEAP32[(($45)>>2)]=0; + var $46=(($ve)|0); + var $47=(($46+4)|0); + HEAP32[(($47)>>2)]=0; + var $48=$2; + var $49=(($48)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($50+292)|0); + var $52=(($51+28)|0); + var $53=$ctx; + var $54=$52; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($53)>>2)]=HEAP32[(($54)>>2)];HEAP32[((($53)+(4))>>2)]=HEAP32[((($54)+(4))>>2)]; + var $55=$typevar; + var $56=_ast_value_copy($55); + $var=$56; + $cleanvar=1; + var $57=$var; + var $58=(($57)|0)!=0; + if ($58) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + var $60=$2; + _parseerror($60, ((STRING_TABLE.__str32604)|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)); + $retval=0; + __label__ = 211; break; + case 13: + var $62=$2; + var $63=(($62+4)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($64)|0)!=129; + if ($65) { __label__ = 14; break; } else { __label__ = 15; break; } + case 14: + var $67=$2; + _parseerror($67, ((STRING_TABLE.__str33605)|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)); + $retval=0; + __label__ = 211; break; + case 15: + var $69=$3; + var $70=(($69)|0)!=0; + if ($70) { __label__ = 27; break; } else { __label__ = 16; break; } + case 16: + $was_end=0; + var $72=$2; + var $73=(($72)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($74+292)|0); + var $76=(($75+4)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=_strcmp($77, ((STRING_TABLE.__str10582)|0)); + var $79=(($78)|0)!=0; + if ($79) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $81=$2; + var $82=(($81+12)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=$2; + var $85=(($84+88)|0); + HEAP32[(($85)>>2)]=$83; + $was_end=1; + __label__ = 21; break; + case 18: + var $87=$2; + var $88=(($87)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($89+292)|0); + var $91=(($90+4)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=_strcmp($92, ((STRING_TABLE.__str11583)|0)); + var $94=(($93)|0)!=0; + if ($94) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + var $96=$2; + var $97=(($96+24)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=$2; + var $100=(($99+92)|0); + HEAP32[(($100)>>2)]=$98; + $was_end=1; + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + var $103=$isfield; + var $104=(($103) & 1); + if ($104) { __label__ = 22; break; } else { __label__ = 26; break; } + case 22: + var $106=$was_end; + var $107=(($106) & 1); + if ($107) { __label__ = 23; break; } else { __label__ = 26; break; } + case 23: + var $109=$2; + var $110=$2; + var $111=(($110)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($112+292)|0); + var $114=(($113+4)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=_parsewarning($109, 15, ((STRING_TABLE.__str34606)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$115,tempInt)); + if ($116) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + $retval=0; + __label__ = 211; break; + case 25: + __label__ = 26; break; + case 26: + __label__ = 27; break; + case 27: + var $121=$var; + var $122=$2; + var $123=(($122)|0); + var $124=HEAP32[(($123)>>2)]; + var $125=(($124+292)|0); + var $126=(($125+4)|0); + var $127=HEAP32[(($126)>>2)]; + var $128=_ast_value_set_name($121, $127); + if ($128) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + var $130=$2; + _parseerror($130, ((STRING_TABLE.__str35607)|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)); + $retval=0; + __label__ = 211; break; + case 29: + var $132=HEAP8[($isfunc)]; + var $133=(($132) & 1); + if ($133) { __label__ = 30; break; } else { __label__ = 48; break; } + case 30: + $proto=0; + var $135=$3; + var $136=(($135)|0)!=0; + if ($136) { __label__ = 32; break; } else { __label__ = 31; break; } + case 31: + var $138=$2; + var $139=$2; + var $140=(($139)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=(($141+292)|0); + var $143=(($142+4)|0); + var $144=HEAP32[(($143)>>2)]; + var $145=_parser_find_global($138, $144); + $olddecl=$145; + __label__ = 33; break; + case 32: + var $147=$2; + var $148=$2; + var $149=(($148)|0); + var $150=HEAP32[(($149)>>2)]; + var $151=(($150+292)|0); + var $152=(($151+4)|0); + var $153=HEAP32[(($152)>>2)]; + var $154=$2; + var $155=(($154+112)|0); + var $156=HEAP32[(($155)>>2)]; + var $157=_parser_find_local($147, $153, $156, $dummy); + $olddecl=$157; + __label__ = 33; break; + case 33: + var $159=$olddecl; + var $160=(($159)|0)!=0; + if ($160) { __label__ = 34; break; } else { __label__ = 37; break; } + case 34: + var $162=$olddecl; + var $163=$162; + var $164=(($163+12)|0); + var $165=HEAP32[(($164)>>2)]; + var $166=(($165)|0)==2; + if ($166) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + var $168=$2; + var $169=$2; + var $170=(($169)|0); + var $171=HEAP32[(($170)>>2)]; + var $172=(($171+292)|0); + var $173=(($172+4)|0); + var $174=HEAP32[(($173)>>2)]; + _parseerror($168, ((STRING_TABLE.__str36608)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$174,tempInt)); + $retval=0; + __label__ = 211; break; + case 36: + var $176=$olddecl; + var $177=$176; + $proto=$177; + __label__ = 37; break; + case 37: + var $179=$var; + var $180=(($179+56)|0); + var $181=HEAP32[(($180)>>2)]; + var $182=(($ctx)|0); + var $183=HEAP32[(($182)>>2)]; + var $184=(($ctx+4)|0); + var $185=HEAP32[(($184)>>2)]; + var $186=_ast_value_new($183, $185, $181, 6); + $fval=$186; + var $187=$fval; + var $188=(($187)|0)!=0; + if ($188) { __label__ = 39; break; } else { __label__ = 38; break; } + case 38: + $retval=0; + __label__ = 211; break; + case 39: + var $191=$var; + var $192=$191; + var $193=$fval; + var $194=(($193)|0); + var $195=(($194+28)|0); + HEAP32[(($195)>>2)]=$192; + var $196=$var; + var $197=(($196)|0); + var $198=(($197+32)|0); + var $199=HEAP32[(($198)>>2)]; + var $200=$fval; + var $201=(($200)|0); + var $202=(($201+32)|0); + HEAP32[(($202)>>2)]=$199; + var $203=$var; + var $204=(($203)|0); + var $205=(($204+36)|0); + var $206=HEAP32[(($205)>>2)]; + var $207=$fval; + var $208=(($207)|0); + var $209=(($208+36)|0); + HEAP32[(($209)>>2)]=$206; + var $210=$var; + var $211=(($210)|0); + var $212=(($211+40)|0); + var $213=HEAP32[(($212)>>2)]; + var $214=$fval; + var $215=(($214)|0); + var $216=(($215+40)|0); + HEAP32[(($216)>>2)]=$213; + var $217=$var; + var $218=(($217)|0); + var $219=(($218+32)|0); + HEAP32[(($219)>>2)]=0; + var $220=$var; + var $221=(($220)|0); + var $222=(($221+36)|0); + HEAP32[(($222)>>2)]=0; + var $223=$var; + var $224=(($223)|0); + var $225=(($224+40)|0); + HEAP32[(($225)>>2)]=0; + var $226=$var; + var $227=(($226)|0); + var $228=(($227+44)|0); + var $229=HEAP8[($228)]; + var $230=(($229) & 1); + var $231=$fval; + var $232=(($231)|0); + var $233=(($232+44)|0); + var $234=(($230)&1); + HEAP8[($233)]=$234; + $var=0; + var $235=$proto; + var $236=(($235)|0)!=0; + if ($236) { __label__ = 40; break; } else { __label__ = 47; break; } + case 40: + var $238=$proto; + var $239=$238; + var $240=$fval; + var $241=$240; + var $242=_ast_compare_type($239, $241); + if ($242) { __label__ = 42; break; } else { __label__ = 41; break; } + case 41: + var $244=$2; + var $245=$proto; + var $246=(($245+56)|0); + var $247=HEAP32[(($246)>>2)]; + var $248=$proto; + var $249=$248; + var $250=(($249)|0); + var $251=(($250)|0); + var $252=HEAP32[(($251)>>2)]; + var $253=$proto; + var $254=$253; + var $255=(($254)|0); + var $256=(($255+4)|0); + var $257=HEAP32[(($256)>>2)]; + _parseerror($244, ((STRING_TABLE.__str37609)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$247,HEAP32[(((tempInt)+(4))>>2)]=$252,HEAP32[(((tempInt)+(8))>>2)]=$257,tempInt)); + var $258=$fval; + _ast_value_delete($258); + $retval=0; + __label__ = 211; break; + case 42: + $param=0; + __label__ = 43; break; + case 43: + var $261=$param; + var $262=$fval; + var $263=(($262)|0); + var $264=(($263+36)|0); + var $265=HEAP32[(($264)>>2)]; + var $266=(($261)>>>0) < (($265)>>>0); + if ($266) { __label__ = 44; break; } else { __label__ = 46; break; } + case 44: + var $268=$param; + var $269=$proto; + var $270=(($269)|0); + var $271=(($270+32)|0); + var $272=HEAP32[(($271)>>2)]; + var $273=(($272+($268<<2))|0); + var $274=HEAP32[(($273)>>2)]; + var $275=$param; + var $276=$fval; + var $277=(($276)|0); + var $278=(($277+32)|0); + var $279=HEAP32[(($278)>>2)]; + var $280=(($279+($275<<2))|0); + var $281=HEAP32[(($280)>>2)]; + var $282=(($281+56)|0); + var $283=HEAP32[(($282)>>2)]; + var $284=_ast_value_set_name($274, $283); + __label__ = 45; break; + case 45: + var $286=$param; + var $287=((($286)+(1))|0); + $param=$287; + __label__ = 43; break; + case 46: + var $289=$proto; + var $290=$289; + var $291=(($290)|0); + var $292=$fval; + var $293=$292; + var $294=(($293)|0); + var $295=$291; + var $296=$294; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($295)>>2)]=HEAP32[(($296)>>2)];HEAP32[((($295)+(4))>>2)]=HEAP32[((($296)+(4))>>2)]; + var $297=$fval; + _ast_value_delete($297); + var $298=$proto; + $fval=$298; + $hadproto=1; + __label__ = 47; break; + case 47: + var $300=$fval; + $var=$300; + __label__ = 48; break; + case 48: + var $302=$isfield; + var $303=(($302) & 1); + if ($303) { __label__ = 49; break; } else { __label__ = 50; break; } + case 49: + var $305=$var; + var $306=(($305+56)|0); + var $307=HEAP32[(($306)>>2)]; + var $308=(($ctx)|0); + var $309=HEAP32[(($308)>>2)]; + var $310=(($ctx+4)|0); + var $311=HEAP32[(($310)>>2)]; + var $312=_ast_value_new($309, $311, $307, 5); + $fld=$312; + var $313=$var; + var $314=$313; + var $315=$fld; + var $316=(($315)|0); + var $317=(($316+28)|0); + HEAP32[(($317)>>2)]=$314; + var $318=$var; + $tmp=$318; + var $319=$fld; + $var=$319; + var $320=$tmp; + $fld=$320; + __label__ = 51; break; + case 50: + var $322=$var; + $fld=$322; + __label__ = 51; break; + case 51: + var $324=HEAP8[($isfunc)]; + var $325=(($324) & 1); + if ($325) { __label__ = 96; break; } else { __label__ = 52; break; } + case 52: + var $327=$3; + var $328=(($327)|0)!=0; + if ($328) { __label__ = 73; break; } else { __label__ = 53; break; } + case 53: + var $330=$2; + var $331=$var; + var $332=(($331+56)|0); + var $333=HEAP32[(($332)>>2)]; + var $334=_parser_find_global($330, $333); + $olddecl=$334; + var $335=$olddecl; + var $336=(($335)|0)!=0; + if ($336) { __label__ = 54; break; } else { __label__ = 60; break; } + case 54: + var $338=$isfield; + var $339=(($338) & 1); + if ($339) { __label__ = 56; break; } else { __label__ = 55; break; } + case 55: + var $341=$2; + var $342=$var; + var $343=(($342+56)|0); + var $344=HEAP32[(($343)>>2)]; + var $345=$olddecl; + var $346=$345; + var $347=(($346)|0); + var $348=(($347)|0); + var $349=HEAP32[(($348)>>2)]; + var $350=$olddecl; + var $351=$350; + var $352=(($351)|0); + var $353=(($352+4)|0); + var $354=HEAP32[(($353)>>2)]; + _parseerror($341, ((STRING_TABLE.__str38610)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$344,HEAP32[(((tempInt)+(4))>>2)]=$349,HEAP32[(((tempInt)+(8))>>2)]=$354,tempInt)); + $retval=0; + __label__ = 211; break; + case 56: + var $356=HEAP32[((_opts_standard)>>2)]; + var $357=(($356)|0)==0; + if ($357) { __label__ = 57; break; } else { __label__ = 58; break; } + case 57: + var $359=$2; + _parseerror($359, ((STRING_TABLE.__str39611)|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)); + var $360=$2; + var $361=$var; + var $362=(($361+56)|0); + var $363=HEAP32[(($362)>>2)]; + var $364=$olddecl; + var $365=$364; + var $366=(($365)|0); + var $367=(($366)|0); + var $368=HEAP32[(($367)>>2)]; + var $369=$olddecl; + var $370=$369; + var $371=(($370)|0); + var $372=(($371+4)|0); + var $373=HEAP32[(($372)>>2)]; + _parseerror($360, ((STRING_TABLE.__str38610)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$363,HEAP32[(((tempInt)+(4))>>2)]=$368,HEAP32[(((tempInt)+(8))>>2)]=$373,tempInt)); + $retval=0; + __label__ = 211; break; + case 58: + __label__ = 59; break; + case 59: + __label__ = 60; break; + case 60: + var $377=$2; + var $378=$var; + var $379=(($378+56)|0); + var $380=HEAP32[(($379)>>2)]; + var $381=_parser_find_field($377, $380); + $olddecl=$381; + var $382=$olddecl; + var $383=(($382)|0)!=0; + if ($383) { __label__ = 61; break; } else { __label__ = 69; break; } + case 61: + var $385=HEAP32[((_opts_standard)>>2)]; + var $386=(($385)|0)==0; + if ($386) { __label__ = 62; break; } else { __label__ = 69; break; } + case 62: + var $388=$isfield; + var $389=(($388) & 1); + if ($389) { __label__ = 64; break; } else { __label__ = 63; break; } + case 63: + var $391=$2; + _parseerror($391, ((STRING_TABLE.__str39611)|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)); + var $392=$2; + var $393=$var; + var $394=(($393+56)|0); + var $395=HEAP32[(($394)>>2)]; + var $396=$olddecl; + var $397=$396; + var $398=(($397)|0); + var $399=(($398)|0); + var $400=HEAP32[(($399)>>2)]; + var $401=$olddecl; + var $402=$401; + var $403=(($402)|0); + var $404=(($403+4)|0); + var $405=HEAP32[(($404)>>2)]; + _parseerror($392, ((STRING_TABLE.__str40612)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$395,HEAP32[(((tempInt)+(4))>>2)]=$400,HEAP32[(((tempInt)+(8))>>2)]=$405,tempInt)); + $retval=0; + __label__ = 211; break; + case 64: + var $407=$2; + var $408=$var; + var $409=(($408+56)|0); + var $410=HEAP32[(($409)>>2)]; + var $411=$olddecl; + var $412=$411; + var $413=(($412)|0); + var $414=(($413)|0); + var $415=HEAP32[(($414)>>2)]; + var $416=$olddecl; + var $417=$416; + var $418=(($417)|0); + var $419=(($418+4)|0); + var $420=HEAP32[(($419)>>2)]; + var $421=_parsewarning($407, 5, ((STRING_TABLE.__str40612)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$410,HEAP32[(((tempInt)+(4))>>2)]=$415,HEAP32[(((tempInt)+(8))>>2)]=$420,tempInt)); + if ($421) { __label__ = 65; break; } else { __label__ = 66; break; } + case 65: + $retval=0; + __label__ = 211; break; + case 66: + var $424=$olddecl; + var $425=$var; + var $426=$425; + var $427=_ast_compare_type($424, $426); + if ($427) { __label__ = 68; break; } else { __label__ = 67; break; } + case 67: + var $429=$2; + var $430=$var; + var $431=(($430+56)|0); + var $432=HEAP32[(($431)>>2)]; + var $433=$olddecl; + var $434=$433; + var $435=(($434)|0); + var $436=(($435)|0); + var $437=HEAP32[(($436)>>2)]; + var $438=$olddecl; + var $439=$438; + var $440=(($439)|0); + var $441=(($440+4)|0); + var $442=HEAP32[(($441)>>2)]; + _parseerror($429, ((STRING_TABLE.__str41613)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$432,HEAP32[(((tempInt)+(4))>>2)]=$437,HEAP32[(((tempInt)+(8))>>2)]=$442,tempInt)); + $retval=0; + __label__ = 211; break; + case 68: + var $444=$var; + var $445=$444; + var $446=$445; + var $447=(($446+8)|0); + var $448=HEAP32[(($447)>>2)]; + var $449=$var; + var $450=$449; + FUNCTION_TABLE[$448]($450); + $var=0; + __label__ = 143; break; + case 69: + var $452=$olddecl; + var $453=(($452)|0)!=0; + if ($453) { __label__ = 70; break; } else { __label__ = 71; break; } + case 70: + var $455=$2; + var $456=$var; + var $457=(($456+56)|0); + var $458=HEAP32[(($457)>>2)]; + var $459=$olddecl; + var $460=$459; + var $461=(($460)|0); + var $462=(($461)|0); + var $463=HEAP32[(($462)>>2)]; + var $464=$olddecl; + var $465=$464; + var $466=(($465)|0); + var $467=(($466+4)|0); + var $468=HEAP32[(($467)>>2)]; + _parseerror($455, ((STRING_TABLE.__str40612)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$458,HEAP32[(((tempInt)+(4))>>2)]=$463,HEAP32[(((tempInt)+(8))>>2)]=$468,tempInt)); + $retval=0; + __label__ = 211; break; + case 71: + __label__ = 72; break; + case 72: + __label__ = 95; break; + case 73: + var $472=$2; + var $473=$var; + var $474=(($473+56)|0); + var $475=HEAP32[(($474)>>2)]; + var $476=$2; + var $477=(($476+112)|0); + var $478=HEAP32[(($477)>>2)]; + var $479=_parser_find_local($472, $475, $478, $isparam); + $olddecl=$479; + var $480=HEAP32[((_opts_standard)>>2)]; + var $481=(($480)|0)==3; + if ($481) { __label__ = 74; break; } else { __label__ = 85; break; } + case 74: + var $483=$olddecl; + var $484=(($483)|0)!=0; + if ($484) { __label__ = 75; break; } else { __label__ = 78; break; } + case 75: + var $486=HEAP8[($isparam)]; + var $487=(($486) & 1); + if ($487) { __label__ = 77; break; } else { __label__ = 76; break; } + case 76: + var $489=$2; + var $490=$var; + var $491=(($490+56)|0); + var $492=HEAP32[(($491)>>2)]; + var $493=$olddecl; + var $494=$493; + var $495=(($494)|0); + var $496=(($495)|0); + var $497=HEAP32[(($496)>>2)]; + var $498=$olddecl; + var $499=$498; + var $500=(($499)|0); + var $501=(($500+4)|0); + var $502=HEAP32[(($501)>>2)]; + _parseerror($489, ((STRING_TABLE.__str42614)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$492,HEAP32[(((tempInt)+(4))>>2)]=$497,HEAP32[(((tempInt)+(8))>>2)]=$502,tempInt)); + $retval=0; + __label__ = 211; break; + case 77: + __label__ = 78; break; + case 78: + var $505=HEAP8[($isparam)]; + var $506=(($505) & 1); + if ($506) { __label__ = 80; break; } else { __label__ = 79; break; } + case 79: + var $508=$olddecl; + var $509=(($508)|0)!=0; + if ($509) { __label__ = 81; break; } else { __label__ = 80; break; } + case 80: + var $511=$2; + var $512=$var; + var $513=(($512+56)|0); + var $514=HEAP32[(($513)>>2)]; + var $515=_parser_find_local($511, $514, 0, $isparam); + $olddecl=$515; + var $516=(($515)|0)!=0; + if ($516) { __label__ = 81; break; } else { __label__ = 84; break; } + case 81: + var $518=$2; + var $519=$var; + var $520=(($519+56)|0); + var $521=HEAP32[(($520)>>2)]; + var $522=_parsewarning($518, 8, ((STRING_TABLE.__str43615)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$521,tempInt)); + if ($522) { __label__ = 82; break; } else { __label__ = 83; break; } + case 82: + var $524=$2; + var $525=$var; + var $526=(($525+56)|0); + var $527=HEAP32[(($526)>>2)]; + var $528=$olddecl; + var $529=$528; + var $530=(($529)|0); + var $531=(($530)|0); + var $532=HEAP32[(($531)>>2)]; + var $533=$olddecl; + var $534=$533; + var $535=(($534)|0); + var $536=(($535+4)|0); + var $537=HEAP32[(($536)>>2)]; + _parseerror($524, ((STRING_TABLE.__str42614)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$527,HEAP32[(((tempInt)+(4))>>2)]=$532,HEAP32[(((tempInt)+(8))>>2)]=$537,tempInt)); + $retval=0; + __label__ = 211; break; + case 83: + __label__ = 84; break; + case 84: + __label__ = 94; break; + case 85: + var $541=$olddecl; + var $542=(($541)|0)!=0; + if ($542) { __label__ = 86; break; } else { __label__ = 93; break; } + case 86: + var $544=HEAP8[($isparam)]; + var $545=(($544) & 1); + if ($545) { __label__ = 87; break; } else { __label__ = 89; break; } + case 87: + var $547=$2; + var $548=$var; + var $549=(($548+56)|0); + var $550=HEAP32[(($549)>>2)]; + var $551=_parsewarning($547, 8, ((STRING_TABLE.__str44616)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$550,tempInt)); + if ($551) { __label__ = 88; break; } else { __label__ = 89; break; } + case 88: + var $553=$var; + _ast_value_delete($553); + $var=0; + $retval=0; + __label__ = 211; break; + case 89: + var $555=HEAP8[($isparam)]; + var $556=(($555) & 1); + if ($556) { __label__ = 91; break; } else { __label__ = 90; break; } + case 90: + var $558=$2; + var $559=$var; + var $560=(($559+56)|0); + var $561=HEAP32[(($560)>>2)]; + var $562=$olddecl; + var $563=$562; + var $564=(($563)|0); + var $565=(($564)|0); + var $566=HEAP32[(($565)>>2)]; + var $567=$olddecl; + var $568=$567; + var $569=(($568)|0); + var $570=(($569+4)|0); + var $571=HEAP32[(($570)>>2)]; + _parseerror($558, ((STRING_TABLE.__str42614)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$561,HEAP32[(((tempInt)+(4))>>2)]=$566,HEAP32[(((tempInt)+(8))>>2)]=$571,tempInt)); + var $572=$var; + _ast_value_delete($572); + $var=0; + $retval=0; + __label__ = 211; break; + case 91: + __label__ = 92; break; + case 92: + var $575=$var; + _ast_value_delete($575); + $var=0; + __label__ = 143; break; + case 93: + __label__ = 94; break; + case 94: + __label__ = 95; break; + case 95: + __label__ = 96; break; + case 96: + var $580=$hadproto; + var $581=(($580) & 1); + if ($581) { __label__ = 142; break; } else { __label__ = 97; break; } + case 97: + var $583=$var; + var $584=(($583+56)|0); + var $585=HEAP32[(($584)>>2)]; + var $586=_util_strdup($585); + var $587=(($varent)|0); + HEAP32[(($587)>>2)]=$586; + var $588=$var; + var $589=$588; + var $590=(($varent+4)|0); + HEAP32[(($590)>>2)]=$589; + var $591=$3; + var $592=(($591)|0)!=0; + if ($592) { __label__ = 106; break; } else { __label__ = 98; break; } + case 98: + var $594=$isfield; + var $595=(($594) & 1); + if ($595) { __label__ = 102; break; } else { __label__ = 99; break; } + case 99: + var $597=$2; + var $598=(($varent)|0); + var $599=HEAP32[(($598)>>2)]; + var $600=(($varent+4)|0); + var $601=HEAP32[(($600)>>2)]; + var $602=_parser_t_globals_add($597, $599, $601); + var $603=(($602)&1); + $retval=$603; + if ($602) { __label__ = 101; break; } else { __label__ = 100; break; } + case 100: + __label__ = 211; break; + case 101: + __label__ = 105; break; + case 102: + var $607=$2; + var $608=(($varent)|0); + var $609=HEAP32[(($608)>>2)]; + var $610=(($varent+4)|0); + var $611=HEAP32[(($610)>>2)]; + var $612=_parser_t_fields_add($607, $609, $611); + var $613=(($612)&1); + $retval=$613; + if ($612) { __label__ = 104; break; } else { __label__ = 103; break; } + case 103: + __label__ = 211; break; + case 104: + __label__ = 105; break; + case 105: + __label__ = 111; break; + case 106: + var $618=$2; + var $619=(($varent)|0); + var $620=HEAP32[(($619)>>2)]; + var $621=(($varent+4)|0); + var $622=HEAP32[(($621)>>2)]; + var $623=_parser_t_locals_add($618, $620, $622); + var $624=(($623)&1); + $retval=$624; + if ($623) { __label__ = 108; break; } else { __label__ = 107; break; } + case 107: + __label__ = 211; break; + case 108: + var $627=$3; + var $628=$var; + var $629=_ast_block_locals_add($627, $628); + var $630=(($629)&1); + $retval=$630; + if ($629) { __label__ = 110; break; } else { __label__ = 109; break; } + case 109: + var $632=$2; + var $633=(($632+104)|0); + var $634=HEAP32[(($633)>>2)]; + var $635=((($634)-(1))|0); + HEAP32[(($633)>>2)]=$635; + __label__ = 211; break; + case 110: + __label__ = 111; break; + case 111: + var $638=$fld; + var $639=(($638)|0); + var $640=(($639+24)|0); + var $641=HEAP32[(($640)>>2)]; + var $642=(($641)|0)==3; + if ($642) { __label__ = 112; break; } else { __label__ = 141; break; } + case 112: + var $644=$2; + var $645=$var; + var $646=(($ve)|0); + var $647=_create_vector_members($644, $645, $646); + if ($647) { __label__ = 114; break; } else { __label__ = 113; break; } + case 113: + $retval=0; + __label__ = 211; break; + case 114: + var $650=$3; + var $651=(($650)|0)!=0; + if ($651) { __label__ = 129; break; } else { __label__ = 115; break; } + case 115: + $e=0; + __label__ = 116; break; + case 116: + var $654=$e; + var $655=(($654)>>>0) < 3; + if ($655) { __label__ = 117; break; } else { __label__ = 126; break; } + case 117: + var $657=$isfield; + var $658=(($657) & 1); + if ($658) { __label__ = 121; break; } else { __label__ = 118; break; } + case 118: + var $660=$2; + var $661=$e; + var $662=(($ve+($661<<3))|0); + var $663=(($662)|0); + var $664=HEAP32[(($663)>>2)]; + var $665=(($662+4)|0); + var $666=HEAP32[(($665)>>2)]; + var $667=_parser_t_globals_add($660, $664, $666); + var $668=(($667)&1); + $retval=$668; + if ($667) { __label__ = 120; break; } else { __label__ = 119; break; } + case 119: + __label__ = 126; break; + case 120: + __label__ = 124; break; + case 121: + var $672=$2; + var $673=$e; + var $674=(($ve+($673<<3))|0); + var $675=(($674)|0); + var $676=HEAP32[(($675)>>2)]; + var $677=(($674+4)|0); + var $678=HEAP32[(($677)>>2)]; + var $679=_parser_t_fields_add($672, $676, $678); + var $680=(($679)&1); + $retval=$680; + if ($679) { __label__ = 123; break; } else { __label__ = 122; break; } + case 122: + __label__ = 126; break; + case 123: + __label__ = 124; break; + case 124: + __label__ = 125; break; + case 125: + var $685=$e; + var $686=((($685)+(1))|0); + $e=$686; + __label__ = 116; break; + case 126: + var $688=$retval; + var $689=(($688) & 1); + if ($689) { __label__ = 128; break; } else { __label__ = 127; break; } + case 127: + var $691=$e; + var $692=((($691)+(1))|0); + var $693=$2; + var $694=(($693+12)|0); + var $695=HEAP32[(($694)>>2)]; + var $696=((($695)-($692))|0); + HEAP32[(($694)>>2)]=$696; + __label__ = 211; break; + case 128: + __label__ = 140; break; + case 129: + $e=0; + __label__ = 130; break; + case 130: + var $700=$e; + var $701=(($700)>>>0) < 3; + if ($701) { __label__ = 131; break; } else { __label__ = 137; break; } + case 131: + var $703=$2; + var $704=$e; + var $705=(($ve+($704<<3))|0); + var $706=(($705)|0); + var $707=HEAP32[(($706)>>2)]; + var $708=(($705+4)|0); + var $709=HEAP32[(($708)>>2)]; + var $710=_parser_t_locals_add($703, $707, $709); + var $711=(($710)&1); + $retval=$711; + if ($710) { __label__ = 133; break; } else { __label__ = 132; break; } + case 132: + __label__ = 137; break; + case 133: + var $714=$3; + var $715=$e; + var $716=(($ve+($715<<3))|0); + var $717=(($716+4)|0); + var $718=HEAP32[(($717)>>2)]; + var $719=_ast_block_collect($714, $718); + var $720=(($719)&1); + $retval=$720; + if ($719) { __label__ = 135; break; } else { __label__ = 134; break; } + case 134: + __label__ = 137; break; + case 135: + var $723=$e; + var $724=(($ve+($723<<3))|0); + var $725=(($724+4)|0); + HEAP32[(($725)>>2)]=0; + __label__ = 136; break; + case 136: + var $727=$e; + var $728=((($727)+(1))|0); + $e=$728; + __label__ = 130; break; + case 137: + var $730=$retval; + var $731=(($730) & 1); + if ($731) { __label__ = 139; break; } else { __label__ = 138; break; } + case 138: + var $733=$e; + var $734=((($733)+(1))|0); + var $735=$2; + var $736=(($735+104)|0); + var $737=HEAP32[(($736)>>2)]; + var $738=((($737)-($734))|0); + HEAP32[(($736)>>2)]=$738; + var $739=$3; + var $740=(($739+60)|0); + var $741=HEAP32[(($740)>>2)]; + var $742=((($741)-(1))|0); + HEAP32[(($740)>>2)]=$742; + __label__ = 211; break; + case 139: + __label__ = 140; break; + case 140: + var $745=(($ve+16)|0); + var $746=(($745)|0); + HEAP32[(($746)>>2)]=0; + var $747=(($ve+8)|0); + var $748=(($747)|0); + HEAP32[(($748)>>2)]=0; + var $749=(($ve)|0); + var $750=(($749)|0); + HEAP32[(($750)>>2)]=0; + var $751=(($ve+16)|0); + var $752=(($751+4)|0); + HEAP32[(($752)>>2)]=0; + var $753=(($ve+8)|0); + var $754=(($753+4)|0); + HEAP32[(($754)>>2)]=0; + var $755=(($ve)|0); + var $756=(($755+4)|0); + HEAP32[(($756)>>2)]=0; + __label__ = 141; break; + case 141: + $cleanvar=0; + var $758=(($varent)|0); + HEAP32[(($758)>>2)]=0; + __label__ = 142; break; + case 142: + __label__ = 143; break; + case 143: + var $761=$2; + var $762=_parser_next($761); + var $763=(($762)&1); + $retval=$763; + if ($762) { __label__ = 145; break; } else { __label__ = 144; break; } + case 144: + __label__ = 211; break; + case 145: + var $766=$2; + var $767=(($766+4)|0); + var $768=HEAP32[(($767)>>2)]; + var $769=(($768)|0)==59; + if ($769) { __label__ = 146; break; } else { __label__ = 147; break; } + case 146: + var $771=$typevar; + _ast_value_delete($771); + var $772=$2; + var $773=_parser_next($772); + $1=$773; + __label__ = 229; break; + case 147: + var $775=$2; + var $776=(($775+4)|0); + var $777=HEAP32[(($776)>>2)]; + var $778=(($777)|0)==44; + if ($778) { __label__ = 148; break; } else { __label__ = 151; break; } + case 148: + var $780=$2; + var $781=_parser_next($780); + var $782=(($781)&1); + $retval=$782; + if ($781) { __label__ = 150; break; } else { __label__ = 149; break; } + case 149: + __label__ = 211; break; + case 150: + __label__ = 11; break; + case 151: + var $786=$3; + var $787=(($786)|0)!=0; + if ($787) { __label__ = 154; break; } else { __label__ = 152; break; } + case 152: + var $789=$isfield; + var $790=(($789) & 1); + if ($790) { __label__ = 153; break; } else { __label__ = 154; break; } + case 153: + var $792=$2; + _parseerror($792, ((STRING_TABLE.__str45617)|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)); + var $793=$typevar; + _ast_value_delete($793); + $1=0; + __label__ = 229; break; + case 154: + var $795=$3; + var $796=(($795)|0)!=0; + if ($796) { __label__ = 155; break; } else { __label__ = 159; break; } + case 155: + var $798=HEAP32[((_opts_standard)>>2)]; + var $799=(($798)|0)==0; + if ($799) { __label__ = 156; break; } else { __label__ = 159; break; } + case 156: + var $801=$2; + var $802=$var; + var $803=(($802+56)|0); + var $804=HEAP32[(($803)>>2)]; + var $805=_parsewarning($801, 9, ((STRING_TABLE.__str46618)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$804,tempInt)); + if ($805) { __label__ = 157; break; } else { __label__ = 158; break; } + case 157: + var $807=$typevar; + _ast_value_delete($807); + $1=0; + __label__ = 229; break; + case 158: + __label__ = 159; break; + case 159: + var $810=$2; + var $811=(($810+4)|0); + var $812=HEAP32[(($811)>>2)]; + var $813=(($812)|0)!=61; + if ($813) { __label__ = 160; break; } else { __label__ = 164; break; } + case 160: + var $815=HEAP32[((_opts_standard)>>2)]; + var $816=(($815)|0)==0; + if ($816) { __label__ = 161; break; } else { __label__ = 162; break; } + case 161: + var $818=$2; + _parseerror($818, ((STRING_TABLE.__str45617)|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)); + __label__ = 163; break; + case 162: + var $820=$2; + _parseerror($820, ((STRING_TABLE.__str47619)|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)); + __label__ = 163; break; + case 163: + var $822=$typevar; + _ast_value_delete($822); + $1=0; + __label__ = 229; break; + case 164: + var $824=$2; + var $825=_parser_next($824); + if ($825) { __label__ = 166; break; } else { __label__ = 165; break; } + case 165: + var $827=$typevar; + _ast_value_delete($827); + $1=0; + __label__ = 229; break; + case 166: + var $829=$2; + var $830=(($829+4)|0); + var $831=HEAP32[(($830)>>2)]; + var $832=(($831)|0)==35; + if ($832) { __label__ = 167; break; } else { __label__ = 184; break; } + case 167: + var $834=$3; + var $835=(($834)|0)!=0; + if ($835) { __label__ = 168; break; } else { __label__ = 169; break; } + case 168: + var $837=$2; + _parseerror($837, ((STRING_TABLE.__str48620)|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)); + var $838=$typevar; + _ast_value_delete($838); + $1=0; + __label__ = 229; break; + case 169: + var $840=HEAP8[($isfunc)]; + var $841=(($840) & 1); + if ($841) { __label__ = 171; break; } else { __label__ = 170; break; } + case 170: + var $843=$2; + var $844=$var; + var $845=(($844+56)|0); + var $846=HEAP32[(($845)>>2)]; + _parseerror($843, ((STRING_TABLE.__str49621)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$846,tempInt)); + var $847=$typevar; + _ast_value_delete($847); + $1=0; + __label__ = 229; break; + case 171: + var $849=$2; + var $850=_parser_next($849); + if ($850) { __label__ = 173; break; } else { __label__ = 172; break; } + case 172: + var $852=$2; + _parseerror($852, ((STRING_TABLE.__str50622)|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)); + var $853=$typevar; + _ast_value_delete($853); + $1=0; + __label__ = 229; break; + case 173: + var $855=$2; + var $856=(($855+4)|0); + var $857=HEAP32[(($856)>>2)]; + var $858=(($857)|0)!=137; + if ($858) { __label__ = 174; break; } else { __label__ = 175; break; } + case 174: + var $860=$2; + _parseerror($860, ((STRING_TABLE.__str51623)|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)); + var $861=$typevar; + _ast_value_delete($861); + $1=0; + __label__ = 229; break; + case 175: + var $863=$2; + var $864=(($863)|0); + var $865=HEAP32[(($864)>>2)]; + var $866=(($865+292)|0); + var $867=(($866+16)|0); + var $868=$867; + var $869=HEAP32[(($868)>>2)]; + var $870=(($869)|0) <= 0; + if ($870) { __label__ = 176; break; } else { __label__ = 177; break; } + case 176: + var $872=$2; + _parseerror($872, ((STRING_TABLE.__str52624)|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)); + var $873=$typevar; + _ast_value_delete($873); + $1=0; + __label__ = 229; break; + case 177: + var $875=$var; + var $876=$875; + var $877=(($876)|0); + var $878=$var; + var $879=(($878+56)|0); + var $880=HEAP32[(($879)>>2)]; + var $881=$var; + var $882=(($877)|0); + var $883=HEAP32[(($882)>>2)]; + var $884=(($877+4)|0); + var $885=HEAP32[(($884)>>2)]; + var $886=_ast_function_new($883, $885, $880, $881); + $func=$886; + var $887=$func; + var $888=(($887)|0)!=0; + if ($888) { __label__ = 179; break; } else { __label__ = 178; break; } + case 178: + var $890=$2; + var $891=$var; + var $892=(($891+56)|0); + var $893=HEAP32[(($892)>>2)]; + _parseerror($890, ((STRING_TABLE.__str53625)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$893,tempInt)); + var $894=$typevar; + _ast_value_delete($894); + $1=0; + __label__ = 229; break; + case 179: + var $896=$2; + var $897=$func; + var $898=_parser_t_functions_add($896, $897); + if ($898) { __label__ = 181; break; } else { __label__ = 180; break; } + case 180: + var $900=$2; + var $901=$var; + var $902=(($901+56)|0); + var $903=HEAP32[(($902)>>2)]; + _parseerror($900, ((STRING_TABLE.__str54626)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$903,tempInt)); + var $904=$func; + _ast_function_delete($904); + var $905=$var; + var $906=(($905+64)|0); + var $907=$906; + HEAP32[(($907)>>2)]=0; + var $908=$typevar; + _ast_value_delete($908); + $1=0; + __label__ = 229; break; + case 181: + var $910=$2; + var $911=(($910)|0); + var $912=HEAP32[(($911)>>2)]; + var $913=(($912+292)|0); + var $914=(($913+16)|0); + var $915=$914; + var $916=HEAP32[(($915)>>2)]; + var $917=(((-$916))|0); + var $918=$func; + var $919=(($918+28)|0); + HEAP32[(($919)>>2)]=$917; + var $920=$2; + var $921=_parser_next($920); + if ($921) { __label__ = 183; break; } else { __label__ = 182; break; } + case 182: + var $923=$typevar; + _ast_value_delete($923); + $1=0; + __label__ = 229; break; + case 183: + __label__ = 206; break; + case 184: + var $926=$2; + var $927=(($926+4)|0); + var $928=HEAP32[(($927)>>2)]; + var $929=(($928)|0)==123; + if ($929) { __label__ = 186; break; } else { __label__ = 185; break; } + case 185: + var $931=$2; + var $932=(($931+4)|0); + var $933=HEAP32[(($932)>>2)]; + var $934=(($933)|0)==91; + if ($934) { __label__ = 186; break; } else { __label__ = 191; break; } + case 186: + var $936=$typevar; + _ast_value_delete($936); + var $937=$3; + var $938=(($937)|0)!=0; + if ($938) { __label__ = 187; break; } else { __label__ = 188; break; } + case 187: + var $940=$2; + _parseerror($940, ((STRING_TABLE.__str55627)|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)); + $1=0; + __label__ = 229; break; + case 188: + var $942=$2; + var $943=$var; + var $944=_parse_function_body($942, $943); + if ($944) { __label__ = 190; break; } else { __label__ = 189; break; } + case 189: + $1=0; + __label__ = 229; break; + case 190: + $1=1; + __label__ = 229; break; + case 191: + var $948=$2; + var $949=_parse_expression_leave($948, 1); + $cexp=$949; + var $950=$cexp; + var $951=(($950)|0)!=0; + if ($951) { __label__ = 193; break; } else { __label__ = 192; break; } + case 192: + var $953=$typevar; + _ast_value_delete($953); + $1=0; + __label__ = 229; break; + case 193: + var $955=$cexp; + var $956=$955; + $cval=$956; + var $957=$cval; + var $958=$957; + var $959=(($958+12)|0); + var $960=HEAP32[(($959)>>2)]; + var $961=(($960)|0)==2; + if ($961) { __label__ = 194; break; } else { __label__ = 195; break; } + case 194: + var $963=$cval; + var $964=(($963+60)|0); + var $965=HEAP8[($964)]; + var $966=(($965) & 1); + if ($966) { __label__ = 196; break; } else { __label__ = 195; break; } + case 195: + var $968=$2; + _parseerror($968, ((STRING_TABLE.__str56628)|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)); + __label__ = 204; break; + case 196: + var $970=$var; + var $971=(($970+60)|0); + HEAP8[($971)]=1; + var $972=$cval; + var $973=(($972)|0); + var $974=(($973+24)|0); + var $975=HEAP32[(($974)>>2)]; + var $976=(($975)|0)==1; + if ($976) { __label__ = 197; break; } else { __label__ = 198; break; } + case 197: + var $978=$cval; + var $979=(($978+64)|0); + var $980=$979; + var $981=HEAP32[(($980)>>2)]; + var $982=_parser_strdup($981); + var $983=$var; + var $984=(($983+64)|0); + var $985=$984; + HEAP32[(($985)>>2)]=$982; + __label__ = 199; break; + case 198: + var $987=$var; + var $988=(($987+64)|0); + var $989=$988; + var $990=$cval; + var $991=(($990+64)|0); + var $992=$991; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($989)>>2)]=HEAP32[(($992)>>2)];HEAP32[((($989)+(4))>>2)]=HEAP32[((($992)+(4))>>2)];HEAP32[((($989)+(8))>>2)]=HEAP32[((($992)+(8))>>2)]; + __label__ = 199; break; + case 199: + __label__ = 200; break; + case 200: + var $995=$cval; + var $996=$995; + var $997=$996; + var $998=(($997+16)|0); + var $999=HEAP8[($998)]; + var $1000=(($999) & 1); + if ($1000) { __label__ = 202; break; } else { __label__ = 201; break; } + case 201: + var $1002=$cval; + var $1003=$1002; + var $1004=$1003; + var $1005=(($1004+8)|0); + var $1006=HEAP32[(($1005)>>2)]; + var $1007=$cval; + var $1008=$1007; + FUNCTION_TABLE[$1006]($1008); + __label__ = 202; break; + case 202: + __label__ = 203; break; + case 203: + __label__ = 204; break; + case 204: + __label__ = 205; break; + case 205: + __label__ = 206; break; + case 206: + var $1014=$2; + var $1015=(($1014+4)|0); + var $1016=HEAP32[(($1015)>>2)]; + var $1017=(($1016)|0)==44; + if ($1017) { __label__ = 207; break; } else { __label__ = 208; break; } + case 207: + __label__ = 11; break; + case 208: + var $1020=$2; + var $1021=(($1020+4)|0); + var $1022=HEAP32[(($1021)>>2)]; + var $1023=(($1022)|0)!=59; + if ($1023) { __label__ = 209; break; } else { __label__ = 210; break; } + case 209: + var $1025=$2; + _parseerror($1025, ((STRING_TABLE.__str45617)|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)); + var $1026=$typevar; + _ast_value_delete($1026); + $1=0; + __label__ = 229; break; + case 210: + var $1028=$2; + var $1029=_parser_next($1028); + var $1030=$typevar; + _ast_value_delete($1030); + $1=1; + __label__ = 229; break; + case 211: + var $1032=$typevar; + var $1033=$1032; + var $1034=$1033; + var $1035=(($1034+8)|0); + var $1036=HEAP32[(($1035)>>2)]; + var $1037=$typevar; + var $1038=$1037; + FUNCTION_TABLE[$1036]($1038); + var $1039=$var; + var $1040=(($1039)|0)!=0; + if ($1040) { __label__ = 212; break; } else { __label__ = 214; break; } + case 212: + var $1042=$cleanvar; + var $1043=(($1042) & 1); + if ($1043) { __label__ = 213; break; } else { __label__ = 214; break; } + case 213: + var $1045=$var; + var $1046=$1045; + var $1047=$1046; + var $1048=(($1047+8)|0); + var $1049=HEAP32[(($1048)>>2)]; + var $1050=$var; + var $1051=$1050; + FUNCTION_TABLE[$1049]($1051); + __label__ = 214; break; + case 214: + var $1053=(($varent)|0); + var $1054=HEAP32[(($1053)>>2)]; + var $1055=(($1054)|0)!=0; + if ($1055) { __label__ = 215; break; } else { __label__ = 216; break; } + case 215: + var $1057=(($varent)|0); + var $1058=HEAP32[(($1057)>>2)]; + _util_memory_d($1058, 2794, ((STRING_TABLE.__str572)|0)); + __label__ = 216; break; + case 216: + var $1060=(($ve)|0); + var $1061=(($1060)|0); + var $1062=HEAP32[(($1061)>>2)]; + var $1063=(($1062)|0)!=0; + if ($1063) { __label__ = 217; break; } else { __label__ = 218; break; } + case 217: + var $1065=(($ve)|0); + var $1066=(($1065)|0); + var $1067=HEAP32[(($1066)>>2)]; + _util_memory_d($1067, 2795, ((STRING_TABLE.__str572)|0)); + __label__ = 218; break; + case 218: + var $1069=(($ve+8)|0); + var $1070=(($1069)|0); + var $1071=HEAP32[(($1070)>>2)]; + var $1072=(($1071)|0)!=0; + if ($1072) { __label__ = 219; break; } else { __label__ = 220; break; } + case 219: + var $1074=(($ve+8)|0); + var $1075=(($1074)|0); + var $1076=HEAP32[(($1075)>>2)]; + _util_memory_d($1076, 2796, ((STRING_TABLE.__str572)|0)); + __label__ = 220; break; + case 220: + var $1078=(($ve+16)|0); + var $1079=(($1078)|0); + var $1080=HEAP32[(($1079)>>2)]; + var $1081=(($1080)|0)!=0; + if ($1081) { __label__ = 221; break; } else { __label__ = 222; break; } + case 221: + var $1083=(($ve+16)|0); + var $1084=(($1083)|0); + var $1085=HEAP32[(($1084)>>2)]; + _util_memory_d($1085, 2797, ((STRING_TABLE.__str572)|0)); + __label__ = 222; break; + case 222: + var $1087=(($ve)|0); + var $1088=(($1087+4)|0); + var $1089=HEAP32[(($1088)>>2)]; + var $1090=(($1089)|0)!=0; + if ($1090) { __label__ = 223; break; } else { __label__ = 224; break; } + case 223: + var $1092=(($ve)|0); + var $1093=(($1092+4)|0); + var $1094=HEAP32[(($1093)>>2)]; + var $1095=$1094; + _util_memory_d($1095, 2798, ((STRING_TABLE.__str572)|0)); + __label__ = 224; break; + case 224: + var $1097=(($ve+8)|0); + var $1098=(($1097+4)|0); + var $1099=HEAP32[(($1098)>>2)]; + var $1100=(($1099)|0)!=0; + if ($1100) { __label__ = 225; break; } else { __label__ = 226; break; } + case 225: + var $1102=(($ve+8)|0); + var $1103=(($1102+4)|0); + var $1104=HEAP32[(($1103)>>2)]; + var $1105=$1104; + _util_memory_d($1105, 2799, ((STRING_TABLE.__str572)|0)); + __label__ = 226; break; + case 226: + var $1107=(($ve+16)|0); + var $1108=(($1107+4)|0); + var $1109=HEAP32[(($1108)>>2)]; + var $1110=(($1109)|0)!=0; + if ($1110) { __label__ = 227; break; } else { __label__ = 228; break; } + case 227: + var $1112=(($ve+16)|0); + var $1113=(($1112+4)|0); + var $1114=HEAP32[(($1113)>>2)]; + var $1115=$1114; + _util_memory_d($1115, 2800, ((STRING_TABLE.__str572)|0)); + __label__ = 228; break; + case 228: + var $1117=$retval; + var $1118=(($1117) & 1); + $1=$1118; + __label__ = 229; break; + case 229: + var $1120=$1; + STACKTOP = __stackBase__; + return $1120; + default: assert(0, "bad label: " + __label__); + } +} +_parse_variable["X"]=1; + +function _parse_type($parser, $basetype, $isfunc) { + var __stackBase__ = STACKTOP; STACKTOP += 24; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $params=__stackBase__; + var $var; + var $ctx=(__stackBase__)+(12); + var $vtype; + var $temptype; + var $i; + var $variadic; + var $param; + var $fld; + var $isfield; + var $isfuncparam=(__stackBase__)+(20); + var $fval; + $2=$parser; + $3=$basetype; + $4=$isfunc; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=$ctx; + var $11=$9; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=$3; + $vtype=$12; + $variadic=0; + var $13=(($params)|0); + HEAP32[(($13)>>2)]=0; + var $14=(($params+4)|0); + HEAP32[(($14)>>2)]=0; + var $15=(($params+8)|0); + HEAP32[(($15)>>2)]=0; + var $16=$4; + HEAP8[($16)]=0; + var $17=$2; + var $18=(($17+4)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($19)|0)==40; + if ($20) { __label__ = 3; break; } else { __label__ = 48; break; } + case 3: + var $22=$4; + HEAP8[($22)]=1; + __label__ = 4; break; + case 4: + $isfield=0; + HEAP8[($isfuncparam)]=0; + var $24=$2; + var $25=_parser_next($24); + if ($25) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + __label__ = 53; break; + case 6: + var $28=$2; + var $29=(($28+4)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30)|0)==41; + if ($31) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + __label__ = 45; break; + case 8: + var $34=$2; + var $35=(($34+4)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36)|0)==46; + if ($37) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + $isfield=1; + var $39=$2; + var $40=_parser_next($39); + if ($40) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $42=$2; + _parseerror($42, ((STRING_TABLE.__str165)|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)); + __label__ = 53; break; + case 11: + __label__ = 12; break; + case 12: + var $45=$2; + var $46=(($45+4)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=(($47)|0)==133; + if ($48) { __label__ = 13; break; } else { __label__ = 22; break; } + case 13: + $variadic=1; + var $50=$2; + var $51=_parser_next($50); + if ($51) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + __label__ = 53; break; + case 15: + var $54=$2; + var $55=(($54+4)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56)|0)!=41; + if ($57) { __label__ = 16; break; } else { __label__ = 17; break; } + case 16: + var $59=$2; + _parseerror($59, ((STRING_TABLE.__str166)|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)); + __label__ = 53; break; + case 17: + var $61=HEAP32[((_opts_standard)>>2)]; + var $62=(($61)|0)==0; + if ($62) { __label__ = 18; break; } else { __label__ = 21; break; } + case 18: + var $64=$2; + var $65=_parsewarning($64, 4, ((STRING_TABLE.__str167)|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)); + if ($65) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + __label__ = 53; break; + case 20: + __label__ = 21; break; + case 21: + __label__ = 45; break; + case 22: + var $70=$2; + var $71=(($70)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=(($72+292)|0); + var $74=(($73+16)|0); + var $75=$74; + var $76=HEAP32[(($75)>>2)]; + $temptype=$76; + var $77=$2; + var $78=_parser_next($77); + if ($78) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + __label__ = 53; break; + case 24: + var $81=$2; + var $82=$temptype; + var $83=_parse_type($81, $82, $isfuncparam); + $param=$83; + var $84=$param; + var $85=(($84)|0)!=0; + if ($85) { __label__ = 26; break; } else { __label__ = 25; break; } + case 25: + __label__ = 53; break; + case 26: + var $88=$2; + var $89=(($88+4)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=(($90)|0)==129; + if ($91) { __label__ = 27; break; } else { __label__ = 32; break; } + case 27: + var $93=$param; + var $94=$2; + var $95=(($94)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=(($96+292)|0); + var $98=(($97+4)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=_ast_value_set_name($93, $99); + if ($100) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + __label__ = 53; break; + case 29: + var $103=$2; + var $104=_parser_next($103); + if ($104) { __label__ = 31; break; } else { __label__ = 30; break; } + case 30: + __label__ = 53; break; + case 31: + __label__ = 32; break; + case 32: + var $108=HEAP8[($isfuncparam)]; + var $109=(($108) & 1); + if ($109) { __label__ = 33; break; } else { __label__ = 36; break; } + case 33: + var $111=$param; + var $112=$111; + var $113=(($112)|0); + var $114=$param; + var $115=(($114+56)|0); + var $116=HEAP32[(($115)>>2)]; + var $117=(($113)|0); + var $118=HEAP32[(($117)>>2)]; + var $119=(($113+4)|0); + var $120=HEAP32[(($119)>>2)]; + var $121=_ast_value_new($118, $120, $116, 6); + $fval=$121; + var $122=$fval; + var $123=(($122)|0)!=0; + if ($123) { __label__ = 35; break; } else { __label__ = 34; break; } + case 34: + var $125=$param; + var $126=$125; + var $127=$126; + var $128=(($127+8)|0); + var $129=HEAP32[(($128)>>2)]; + var $130=$param; + var $131=$130; + FUNCTION_TABLE[$129]($131); + __label__ = 53; break; + case 35: + var $133=$param; + var $134=$133; + var $135=$fval; + var $136=(($135)|0); + var $137=(($136+28)|0); + HEAP32[(($137)>>2)]=$134; + var $138=$param; + var $139=(($138)|0); + var $140=(($139+32)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=$fval; + var $143=(($142)|0); + var $144=(($143+32)|0); + HEAP32[(($144)>>2)]=$141; + var $145=$param; + var $146=(($145)|0); + var $147=(($146+36)|0); + var $148=HEAP32[(($147)>>2)]; + var $149=$fval; + var $150=(($149)|0); + var $151=(($150+36)|0); + HEAP32[(($151)>>2)]=$148; + var $152=$param; + var $153=(($152)|0); + var $154=(($153+40)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=$fval; + var $157=(($156)|0); + var $158=(($157+40)|0); + HEAP32[(($158)>>2)]=$155; + var $159=$param; + var $160=(($159)|0); + var $161=(($160+32)|0); + HEAP32[(($161)>>2)]=0; + var $162=$param; + var $163=(($162)|0); + var $164=(($163+36)|0); + HEAP32[(($164)>>2)]=0; + var $165=$param; + var $166=(($165)|0); + var $167=(($166+40)|0); + HEAP32[(($167)>>2)]=0; + var $168=$param; + var $169=(($168)|0); + var $170=(($169+44)|0); + var $171=HEAP8[($170)]; + var $172=(($171) & 1); + var $173=$fval; + var $174=(($173)|0); + var $175=(($174+44)|0); + var $176=(($172)&1); + HEAP8[($175)]=$176; + var $177=$fval; + $param=$177; + __label__ = 36; break; + case 36: + var $179=$isfield; + var $180=(($179) & 1); + if ($180) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + var $182=$param; + var $183=(($182+56)|0); + var $184=HEAP32[(($183)>>2)]; + var $185=(($ctx)|0); + var $186=HEAP32[(($185)>>2)]; + var $187=(($ctx+4)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=_ast_value_new($186, $188, $184, 5); + $fld=$189; + var $190=$param; + var $191=$190; + var $192=$fld; + var $193=(($192)|0); + var $194=(($193+28)|0); + HEAP32[(($194)>>2)]=$191; + var $195=$fld; + $param=$195; + __label__ = 38; break; + case 38: + var $197=$param; + var $198=_paramlist_t_p_add($params, $197); + if ($198) { __label__ = 40; break; } else { __label__ = 39; break; } + case 39: + var $200=$2; + _parseerror($200, ((STRING_TABLE.__str168)|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)); + __label__ = 53; break; + case 40: + var $202=$2; + var $203=(($202+4)|0); + var $204=HEAP32[(($203)>>2)]; + var $205=(($204)|0)==44; + if ($205) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + __label__ = 4; break; + case 42: + var $208=$2; + var $209=(($208+4)|0); + var $210=HEAP32[(($209)>>2)]; + var $211=(($210)|0)==41; + if ($211) { __label__ = 43; break; } else { __label__ = 44; break; } + case 43: + __label__ = 45; break; + case 44: + var $214=$2; + _parseerror($214, ((STRING_TABLE.__str169)|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)); + __label__ = 53; break; + case 45: + var $216=$2; + var $217=_parser_next($216); + if ($217) { __label__ = 47; break; } else { __label__ = 46; break; } + case 46: + __label__ = 53; break; + case 47: + __label__ = 48; break; + case 48: + var $221=(($params+4)|0); + var $222=HEAP32[(($221)>>2)]; + var $223=(($222)>>>0) > 8; + if ($223) { __label__ = 49; break; } else { __label__ = 50; break; } + case 49: + var $225=$2; + _parseerror($225, ((STRING_TABLE.__str170)|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)); + __label__ = 50; break; + case 50: + var $227=$vtype; + var $228=(($ctx)|0); + var $229=HEAP32[(($228)>>2)]; + var $230=(($ctx+4)|0); + var $231=HEAP32[(($230)>>2)]; + var $232=_ast_value_new($229, $231, ((STRING_TABLE.__str171)|0), $227); + $var=$232; + var $233=$var; + var $234=(($233)|0)!=0; + if ($234) { __label__ = 52; break; } else { __label__ = 51; break; } + case 51: + __label__ = 53; break; + case 52: + var $237=$variadic; + var $238=(($237) & 1); + var $239=$var; + var $240=(($239)|0); + var $241=(($240+44)|0); + var $242=(($238)&1); + HEAP8[($241)]=$242; + var $243=(($params)|0); + var $244=HEAP32[(($243)>>2)]; + var $245=$var; + var $246=(($245)|0); + var $247=(($246+32)|0); + HEAP32[(($247)>>2)]=$244; + var $248=(($params+4)|0); + var $249=HEAP32[(($248)>>2)]; + var $250=$var; + var $251=(($250)|0); + var $252=(($251+36)|0); + HEAP32[(($252)>>2)]=$249; + var $253=(($params+8)|0); + var $254=HEAP32[(($253)>>2)]; + var $255=$var; + var $256=(($255)|0); + var $257=(($256+40)|0); + HEAP32[(($257)>>2)]=$254; + var $258=(($params)|0); + HEAP32[(($258)>>2)]=0; + var $259=(($params+4)|0); + HEAP32[(($259)>>2)]=0; + var $260=(($params+8)|0); + HEAP32[(($260)>>2)]=0; + var $261=$var; + $1=$261; + __label__ = 60; break; + case 53: + $i=0; + __label__ = 54; break; + case 54: + var $264=$i; + var $265=(($params+4)|0); + var $266=HEAP32[(($265)>>2)]; + var $267=(($264)>>>0) < (($266)>>>0); + if ($267) { __label__ = 55; break; } else { __label__ = 57; break; } + case 55: + var $269=$i; + var $270=(($params)|0); + var $271=HEAP32[(($270)>>2)]; + var $272=(($271+($269<<2))|0); + var $273=HEAP32[(($272)>>2)]; + _ast_value_delete($273); + __label__ = 56; break; + case 56: + var $275=$i; + var $276=((($275)+(1))|0); + $i=$276; + __label__ = 54; break; + case 57: + var $278=(($params)|0); + var $279=HEAP32[(($278)>>2)]; + var $280=(($279)|0)!=0; + if ($280) { __label__ = 58; break; } else { __label__ = 59; break; } + case 58: + var $282=(($params)|0); + var $283=HEAP32[(($282)>>2)]; + var $284=$283; + _util_memory_d($284, 430, ((STRING_TABLE.__str572)|0)); + __label__ = 59; break; + case 59: + var $286=(($params)|0); + HEAP32[(($286)>>2)]=0; + var $287=(($params+4)|0); + HEAP32[(($287)>>2)]=0; + var $288=(($params+8)|0); + HEAP32[(($288)>>2)]=0; + $1=0; + __label__ = 60; break; + case 60: + var $290=$1; + STACKTOP = __stackBase__; + return $290; + default: assert(0, "bad label: " + __label__); + } +} +_parse_type["X"]=1; + +function _parsewarning($parser, $warntype, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $ap=__stackBase__; + var $lvl; + $2=$parser; + $3=$warntype; + $4=$fmt; + $lvl=1; + var $5=$3; + var $6=((((($5)|0))/(32))&-1); + var $7=((_opts_warn+($6<<2))|0); + var $8=HEAP32[(($7)>>2)]; + var $9=$3; + var $10=((($9)|0))%(32); + var $11=1 << $10; + var $12=$8 & $11; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $16=HEAP8[(_opts_werror)]; + var $17=(($16) & 1); + if ($17) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $19=$2; + var $20=(($19+116)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21)+(1))|0); + HEAP32[(($20)>>2)]=$22; + $lvl=2; + __label__ = 6; break; + case 6: + var $24=$ap; + HEAP32[(($24)>>2)]=arguments[_parsewarning.length]; + var $25=$lvl; + var $26=$2; + var $27=(($26)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28+292)|0); + var $30=(($29+28)|0); + var $31=(($30)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$2; + var $34=(($33)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+292)|0); + var $37=(($36+28)|0); + var $38=(($37+4)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$4; + var $41=HEAP32[(($ap)>>2)]; + _vprintmsg($25, $32, $39, ((STRING_TABLE.__str28600)|0), $40, $41); + var $42=$ap; + ; + var $43=HEAP8[(_opts_werror)]; + var $44=(($43) & 1); + $1=$44; + __label__ = 7; break; + case 7: + var $46=$1; + STACKTOP = __stackBase__; + return $46; + default: assert(0, "bad label: " + __label__); + } +} +_parsewarning["X"]=1; + +function _parser_find_global($parser, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$parser; + $3=$name; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+12)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+8)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<3))|0); + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$3; + var $19=_strcmp($17, $18); + var $20=(($19)|0)!=0; + if ($20) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $22=$i; + var $23=$2; + var $24=(($23+8)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25+($22<<3))|0); + var $27=(($26+4)|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_find_local($parser, $name, $upto, $isparam) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $i; + $2=$parser; + $3=$name; + $4=$upto; + $5=$isparam; + var $6=$5; + HEAP8[($6)]=0; + var $7=$2; + var $8=(($7+104)|0); + var $9=HEAP32[(($8)>>2)]; + $i=$9; + __label__ = 3; break; + case 3: + var $11=$i; + var $12=$4; + var $13=(($11)>>>0) > (($12)>>>0); + if ($13) { __label__ = 4; break; } else { __label__ = 7; break; } + case 4: + var $15=$i; + var $16=((($15)-(1))|0); + $i=$16; + var $17=$i; + var $18=$2; + var $19=(($18+100)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20+($17<<3))|0); + var $22=(($21)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$3; + var $25=_strcmp($23, $24); + var $26=(($25)|0)!=0; + if ($26) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $28=$i; + var $29=$2; + var $30=(($29+100)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31+($28<<3))|0); + var $33=(($32+4)|0); + var $34=HEAP32[(($33)>>2)]; + $1=$34; + __label__ = 8; break; + case 6: + __label__ = 3; break; + case 7: + var $37=$5; + HEAP8[($37)]=1; + var $38=$2; + var $39=$3; + var $40=_parser_find_param($38, $39); + $1=$40; + __label__ = 8; break; + case 8: + var $42=$1; + ; + return $42; + default: assert(0, "bad label: " + __label__); + } +} +_parser_find_local["X"]=1; + +function _parser_find_field($parser, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$parser; + $3=$name; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+24)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<3))|0); + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$3; + var $19=_strcmp($17, $18); + var $20=(($19)|0)!=0; + if ($20) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $22=$i; + var $23=$2; + var $24=(($23+20)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25+($22<<3))|0); + var $27=(($26+4)|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $35=$1; + ; + return $35; + default: assert(0, "bad label: " + __label__); + } +} + + +function _create_vector_members($parser, $var, $ve) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $i; + var $len; + $2=$parser; + $3=$var; + $4=$ve; + var $5=$3; + var $6=(($5+56)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=_strlen($7); + $len=$8; + $i=0; + __label__ = 3; break; + case 3: + var $10=$i; + var $11=(($10)>>>0) < 3; + if ($11) { __label__ = 4; break; } else { __label__ = 10; break; } + case 4: + var $13=$3; + var $14=$13; + var $15=(($14)|0); + var $16=$3; + var $17=$16; + var $18=$i; + var $19=(($15)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($15+4)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=_ast_member_new($20, $22, $17, $18); + var $24=$23; + var $25=$i; + var $26=$4; + var $27=(($26+($25<<3))|0); + var $28=(($27+4)|0); + HEAP32[(($28)>>2)]=$24; + var $29=$i; + var $30=$4; + var $31=(($30+($29<<3))|0); + var $32=(($31+4)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33)|0)!=0; + if ($34) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + __label__ = 10; break; + case 6: + var $37=$len; + var $38=((($37)+(3))|0); + var $39=_util_memory_a($38, 1937, ((STRING_TABLE.__str572)|0)); + var $40=$i; + var $41=$4; + var $42=(($41+($40<<3))|0); + var $43=(($42)|0); + HEAP32[(($43)>>2)]=$39; + var $44=$i; + var $45=$4; + var $46=(($45+($44<<3))|0); + var $47=(($46)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48)|0)!=0; + if ($49) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $51=$i; + var $52=$4; + var $53=(($52+($51<<3))|0); + var $54=(($53+4)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$55; + var $57=$56; + var $58=(($57+8)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=$i; + var $61=$4; + var $62=(($61+($60<<3))|0); + var $63=(($62+4)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=$64; + FUNCTION_TABLE[$59]($65); + __label__ = 10; break; + case 8: + var $67=$i; + var $68=$4; + var $69=(($68+($67<<3))|0); + var $70=(($69)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$3; + var $73=(($72+56)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=$len; + assert($75 % 1 === 0, 'memcpy given ' + $75 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($71, $74, $75, 1); + var $76=$len; + var $77=$i; + var $78=$4; + var $79=(($78+($77<<3))|0); + var $80=(($79)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81+$76)|0); + HEAP8[($82)]=95; + var $83=$i; + var $84=((($83)+(120))|0); + var $85=(($84) & 255); + var $86=$len; + var $87=((($86)+(1))|0); + var $88=$i; + var $89=$4; + var $90=(($89+($88<<3))|0); + var $91=(($90)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($92+$87)|0); + HEAP8[($93)]=$85; + var $94=$len; + var $95=((($94)+(2))|0); + var $96=$i; + var $97=$4; + var $98=(($97+($96<<3))|0); + var $99=(($98)|0); + var $100=HEAP32[(($99)>>2)]; + var $101=(($100+$95)|0); + HEAP8[($101)]=0; + __label__ = 9; break; + case 9: + var $103=$i; + var $104=((($103)+(1))|0); + $i=$104; + __label__ = 3; break; + case 10: + var $106=$i; + var $107=(($106)|0)==3; + if ($107) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + $1=1; + __label__ = 16; break; + case 12: + __label__ = 13; break; + case 13: + var $111=$i; + var $112=((($111)-(1))|0); + $i=$112; + var $113=$i; + var $114=$4; + var $115=(($114+($113<<3))|0); + var $116=(($115)|0); + var $117=HEAP32[(($116)>>2)]; + _util_memory_d($117, 1954, ((STRING_TABLE.__str572)|0)); + var $118=$i; + var $119=$4; + var $120=(($119+($118<<3))|0); + var $121=(($120+4)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=$122; + var $124=$123; + var $125=(($124+8)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=$i; + var $128=$4; + var $129=(($128+($127<<3))|0); + var $130=(($129+4)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=$131; + FUNCTION_TABLE[$126]($132); + var $133=$i; + var $134=$4; + var $135=(($134+($133<<3))|0); + var $136=(($135)|0); + HEAP32[(($136)>>2)]=0; + var $137=$i; + var $138=$4; + var $139=(($138+($137<<3))|0); + var $140=(($139+4)|0); + HEAP32[(($140)>>2)]=0; + __label__ = 14; break; + case 14: + var $142=$i; + var $143=(($142)|0)!=0; + if ($143) { __label__ = 13; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 16; break; + case 16: + var $146=$1; + ; + return $146; + default: assert(0, "bad label: " + __label__); + } +} +_create_vector_members["X"]=1; + +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. + +function _parse_function_body($parser, $var) { + var __stackBase__ = STACKTOP; STACKTOP += 40; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $block; + var $func; + var $old; + var $parami; + var $framenum; + var $nextthink; + var $fld_think; + var $fld_nextthink; + var $fld_frame; + var $gbl_time; + var $gbl_self; + var $has_frame_think; + var $retval; + var $varent=__stackBase__; + var $thinkfunc; + var $functype; + var $ctx=(__stackBase__)+(8); + var $self_frame; + var $self_nextthink; + var $self_think; + var $time_plus_1; + var $store_frame; + var $store_nextthink; + var $store_think; + var $e; + var $ve=(__stackBase__)+(16); + var $param; + $2=$parser; + $3=$var; + $block=0; + $framenum=0; + $nextthink=0; + $fld_think=0; + $fld_nextthink=0; + $fld_frame=0; + $gbl_time=0; + $gbl_self=0; + $retval=1; + $has_frame_think=0; + var $4=$2; + var $5=(($4+96)|0); + var $6=HEAP32[(($5)>>2)]; + $old=$6; + var $7=$3; + var $8=(($7)|0); + var $9=(($8+44)|0); + var $10=HEAP8[($9)]; + var $11=(($10) & 1); + if ($11) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $13=$2; + var $14=_parsewarning($13, 12, ((STRING_TABLE.__str103675)|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)); + if ($14) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $1=0; + __label__ = 198; break; + case 5: + __label__ = 6; break; + case 6: + var $18=$2; + var $19=(($18+4)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20)|0)==91; + if ($21) { __label__ = 7; break; } else { __label__ = 88; break; } + case 7: + $nextthink=0; + var $23=$2; + var $24=_parser_find_field($23, ((STRING_TABLE.__str104676)|0)); + $fld_think=$24; + var $25=$2; + var $26=_parser_find_field($25, ((STRING_TABLE.__str105677)|0)); + $fld_nextthink=$26; + var $27=$2; + var $28=_parser_find_field($27, ((STRING_TABLE.__str106678)|0)); + $fld_frame=$28; + var $29=$fld_think; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 8; break; } else { __label__ = 10; break; } + case 8: + var $32=$fld_nextthink; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $35=$fld_frame; + var $36=(($35)|0)!=0; + if ($36) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $38=$2; + _parseerror($38, ((STRING_TABLE.__str107679)|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)); + var $39=$2; + _parseerror($39, ((STRING_TABLE.__str108680)|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)); + $1=0; + __label__ = 198; break; + case 11: + var $41=$2; + var $42=_parser_find_global($41, ((STRING_TABLE.__str109681)|0)); + $gbl_time=$42; + var $43=$2; + var $44=_parser_find_global($43, ((STRING_TABLE.__str110682)|0)); + $gbl_self=$44; + var $45=$gbl_time; + var $46=(($45)|0)!=0; + if ($46) { __label__ = 12; break; } else { __label__ = 13; break; } + case 12: + var $48=$gbl_self; + var $49=(($48)|0)!=0; + if ($49) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + var $51=$2; + _parseerror($51, ((STRING_TABLE.__str111683)|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)); + var $52=$2; + _parseerror($52, ((STRING_TABLE.__str112684)|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)); + $1=0; + __label__ = 198; break; + case 14: + var $54=$2; + var $55=_parser_next($54); + if ($55) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 198; break; + case 16: + var $58=$2; + var $59=_parse_expression_leave($58, 1); + $framenum=$59; + var $60=$framenum; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $63=$2; + _parseerror($63, ((STRING_TABLE.__str113685)|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)); + $1=0; + __label__ = 198; break; + case 18: + var $65=$framenum; + var $66=$65; + var $67=(($66+12)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=(($68)|0)==2; + if ($69) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $71=$framenum; + var $72=$71; + var $73=(($72+60)|0); + var $74=HEAP8[($73)]; + var $75=(($74) & 1); + if ($75) { __label__ = 25; break; } else { __label__ = 20; break; } + case 20: + __label__ = 21; break; + case 21: + var $78=$framenum; + var $79=$78; + var $80=$79; + var $81=(($80+16)|0); + var $82=HEAP8[($81)]; + var $83=(($82) & 1); + if ($83) { __label__ = 23; break; } else { __label__ = 22; break; } + case 22: + var $85=$framenum; + var $86=$85; + var $87=$86; + var $88=(($87+8)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=$framenum; + var $91=$90; + FUNCTION_TABLE[$89]($91); + __label__ = 23; break; + case 23: + __label__ = 24; break; + case 24: + var $94=$2; + _parseerror($94, ((STRING_TABLE.__str114686)|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)); + $1=0; + __label__ = 198; break; + case 25: + var $96=$2; + var $97=(($96+4)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=(($98)|0)!=44; + if ($99) { __label__ = 26; break; } else { __label__ = 31; break; } + case 26: + __label__ = 27; break; + case 27: + var $102=$framenum; + var $103=$102; + var $104=$103; + var $105=(($104+16)|0); + var $106=HEAP8[($105)]; + var $107=(($106) & 1); + if ($107) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + var $109=$framenum; + var $110=$109; + var $111=$110; + var $112=(($111+8)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$framenum; + var $115=$114; + FUNCTION_TABLE[$113]($115); + __label__ = 29; break; + case 29: + __label__ = 30; break; + case 30: + var $118=$2; + _parseerror($118, ((STRING_TABLE.__str115687)|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)); + var $119=$2; + var $120=$2; + var $121=(($120+4)|0); + var $122=HEAP32[(($121)>>2)]; + _parseerror($119, ((STRING_TABLE.__str116688)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$122,tempInt)); + $1=0; + __label__ = 198; break; + case 31: + var $124=$2; + var $125=_parser_next($124); + if ($125) { __label__ = 37; break; } else { __label__ = 32; break; } + case 32: + __label__ = 33; break; + case 33: + var $128=$framenum; + var $129=$128; + var $130=$129; + var $131=(($130+16)|0); + var $132=HEAP8[($131)]; + var $133=(($132) & 1); + if ($133) { __label__ = 35; break; } else { __label__ = 34; break; } + case 34: + var $135=$framenum; + var $136=$135; + var $137=$136; + var $138=(($137+8)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=$framenum; + var $141=$140; + FUNCTION_TABLE[$139]($141); + __label__ = 35; break; + case 35: + __label__ = 36; break; + case 36: + $1=0; + __label__ = 198; break; + case 37: + var $145=$2; + var $146=(($145+4)|0); + var $147=HEAP32[(($146)>>2)]; + var $148=(($147)|0)==129; + if ($148) { __label__ = 38; break; } else { __label__ = 59; break; } + case 38: + var $150=$2; + var $151=$2; + var $152=(($151)|0); + var $153=HEAP32[(($152)>>2)]; + var $154=(($153+292)|0); + var $155=(($154+4)|0); + var $156=HEAP32[(($155)>>2)]; + var $157=_parser_find_var($150, $156); + var $158=(($157)|0)!=0; + if ($158) { __label__ = 59; break; } else { __label__ = 39; break; } + case 39: + var $160=$fld_think; + var $161=$160; + var $162=(($161+28)|0); + var $163=HEAP32[(($162)>>2)]; + $functype=$163; + var $164=$2; + var $165=(($164)|0); + var $166=HEAP32[(($165)>>2)]; + var $167=(($166+292)|0); + var $168=(($167+28)|0); + var $169=$2; + var $170=(($169)|0); + var $171=HEAP32[(($170)>>2)]; + var $172=(($171+292)|0); + var $173=(($172+4)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=$functype; + var $176=$175; + var $177=(($176+24)|0); + var $178=HEAP32[(($177)>>2)]; + var $179=(($168)|0); + var $180=HEAP32[(($179)>>2)]; + var $181=(($168+4)|0); + var $182=HEAP32[(($181)>>2)]; + var $183=_ast_value_new($180, $182, $174, $178); + $thinkfunc=$183; + var $184=$thinkfunc; + var $185=(($184)|0)!=0; + if ($185) { __label__ = 40; break; } else { __label__ = 41; break; } + case 40: + var $187=$thinkfunc; + var $188=$187; + var $189=$functype; + var $190=_ast_type_adopt_impl($188, $189); + if ($190) { __label__ = 46; break; } else { __label__ = 41; break; } + case 41: + __label__ = 42; break; + case 42: + var $193=$framenum; + var $194=$193; + var $195=$194; + var $196=(($195+16)|0); + var $197=HEAP8[($196)]; + var $198=(($197) & 1); + if ($198) { __label__ = 44; break; } else { __label__ = 43; break; } + case 43: + var $200=$framenum; + var $201=$200; + var $202=$201; + var $203=(($202+8)|0); + var $204=HEAP32[(($203)>>2)]; + var $205=$framenum; + var $206=$205; + FUNCTION_TABLE[$204]($206); + __label__ = 44; break; + case 44: + __label__ = 45; break; + case 45: + var $209=$2; + var $210=$2; + var $211=(($210)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=(($212+292)|0); + var $214=(($213+4)|0); + var $215=HEAP32[(($214)>>2)]; + _parseerror($209, ((STRING_TABLE.__str117689)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$215,tempInt)); + $1=0; + __label__ = 198; break; + case 46: + var $217=$2; + var $218=_parser_next($217); + if ($218) { __label__ = 52; break; } else { __label__ = 47; break; } + case 47: + __label__ = 48; break; + case 48: + var $221=$framenum; + var $222=$221; + var $223=$222; + var $224=(($223+16)|0); + var $225=HEAP8[($224)]; + var $226=(($225) & 1); + if ($226) { __label__ = 50; break; } else { __label__ = 49; break; } + case 49: + var $228=$framenum; + var $229=$228; + var $230=$229; + var $231=(($230+8)|0); + var $232=HEAP32[(($231)>>2)]; + var $233=$framenum; + var $234=$233; + FUNCTION_TABLE[$232]($234); + __label__ = 50; break; + case 50: + __label__ = 51; break; + case 51: + var $237=$thinkfunc; + var $238=$237; + var $239=$238; + var $240=(($239+8)|0); + var $241=HEAP32[(($240)>>2)]; + var $242=$thinkfunc; + var $243=$242; + FUNCTION_TABLE[$241]($243); + $1=0; + __label__ = 198; break; + case 52: + var $245=$thinkfunc; + var $246=$245; + var $247=(($varent+4)|0); + HEAP32[(($247)>>2)]=$246; + var $248=$thinkfunc; + var $249=(($248+56)|0); + var $250=HEAP32[(($249)>>2)]; + var $251=_util_strdup($250); + var $252=(($varent)|0); + HEAP32[(($252)>>2)]=$251; + var $253=$2; + var $254=(($varent)|0); + var $255=HEAP32[(($254)>>2)]; + var $256=(($varent+4)|0); + var $257=HEAP32[(($256)>>2)]; + var $258=_parser_t_globals_add($253, $255, $257); + if ($258) { __label__ = 58; break; } else { __label__ = 53; break; } + case 53: + __label__ = 54; break; + case 54: + var $261=$framenum; + var $262=$261; + var $263=$262; + var $264=(($263+16)|0); + var $265=HEAP8[($264)]; + var $266=(($265) & 1); + if ($266) { __label__ = 56; break; } else { __label__ = 55; break; } + case 55: + var $268=$framenum; + var $269=$268; + var $270=$269; + var $271=(($270+8)|0); + var $272=HEAP32[(($271)>>2)]; + var $273=$framenum; + var $274=$273; + FUNCTION_TABLE[$272]($274); + __label__ = 56; break; + case 56: + __label__ = 57; break; + case 57: + var $277=$thinkfunc; + var $278=$277; + var $279=$278; + var $280=(($279+8)|0); + var $281=HEAP32[(($280)>>2)]; + var $282=$thinkfunc; + var $283=$282; + FUNCTION_TABLE[$281]($283); + $1=0; + __label__ = 198; break; + case 58: + var $285=$thinkfunc; + var $286=$285; + $nextthink=$286; + __label__ = 66; break; + case 59: + var $288=$2; + var $289=_parse_expression_leave($288, 1); + $nextthink=$289; + var $290=$nextthink; + var $291=(($290)|0)!=0; + if ($291) { __label__ = 65; break; } else { __label__ = 60; break; } + case 60: + __label__ = 61; break; + case 61: + var $294=$framenum; + var $295=$294; + var $296=$295; + var $297=(($296+16)|0); + var $298=HEAP8[($297)]; + var $299=(($298) & 1); + if ($299) { __label__ = 63; break; } else { __label__ = 62; break; } + case 62: + var $301=$framenum; + var $302=$301; + var $303=$302; + var $304=(($303+8)|0); + var $305=HEAP32[(($304)>>2)]; + var $306=$framenum; + var $307=$306; + FUNCTION_TABLE[$305]($307); + __label__ = 63; break; + case 63: + __label__ = 64; break; + case 64: + var $310=$2; + _parseerror($310, ((STRING_TABLE.__str118690)|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)); + $1=0; + __label__ = 198; break; + case 65: + __label__ = 66; break; + case 66: + var $313=$nextthink; + var $314=$313; + var $315=(($314+12)|0); + var $316=HEAP32[(($315)>>2)]; + var $317=(($316)|0)==2; + if ($317) { __label__ = 68; break; } else { __label__ = 67; break; } + case 67: + var $319=$2; + _parseerror($319, ((STRING_TABLE.__str119691)|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)); + $retval=0; + __label__ = 68; break; + case 68: + var $321=$retval; + var $322=(($321) & 1); + if ($322) { __label__ = 69; break; } else { __label__ = 71; break; } + case 69: + var $324=$2; + var $325=(($324+4)|0); + var $326=HEAP32[(($325)>>2)]; + var $327=(($326)|0)!=93; + if ($327) { __label__ = 70; break; } else { __label__ = 71; break; } + case 70: + var $329=$2; + _parseerror($329, ((STRING_TABLE.__str120692)|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)); + $retval=0; + __label__ = 71; break; + case 71: + var $331=$retval; + var $332=(($331) & 1); + if ($332) { __label__ = 72; break; } else { __label__ = 74; break; } + case 72: + var $334=$2; + var $335=_parser_next($334); + if ($335) { __label__ = 74; break; } else { __label__ = 73; break; } + case 73: + $retval=0; + __label__ = 74; break; + case 74: + var $338=$retval; + var $339=(($338) & 1); + if ($339) { __label__ = 75; break; } else { __label__ = 77; break; } + case 75: + var $341=$2; + var $342=(($341+4)|0); + var $343=HEAP32[(($342)>>2)]; + var $344=(($343)|0)!=123; + if ($344) { __label__ = 76; break; } else { __label__ = 77; break; } + case 76: + var $346=$2; + _parseerror($346, ((STRING_TABLE.__str121693)|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)); + $retval=0; + __label__ = 77; break; + case 77: + var $348=$retval; + var $349=(($348) & 1); + if ($349) { __label__ = 87; break; } else { __label__ = 78; break; } + case 78: + __label__ = 79; break; + case 79: + var $352=$nextthink; + var $353=$352; + var $354=$353; + var $355=(($354+16)|0); + var $356=HEAP8[($355)]; + var $357=(($356) & 1); + if ($357) { __label__ = 81; break; } else { __label__ = 80; break; } + case 80: + var $359=$nextthink; + var $360=$359; + var $361=$360; + var $362=(($361+8)|0); + var $363=HEAP32[(($362)>>2)]; + var $364=$nextthink; + var $365=$364; + FUNCTION_TABLE[$363]($365); + __label__ = 81; break; + case 81: + __label__ = 82; break; + case 82: + __label__ = 83; break; + case 83: + var $369=$framenum; + var $370=$369; + var $371=$370; + var $372=(($371+16)|0); + var $373=HEAP8[($372)]; + var $374=(($373) & 1); + if ($374) { __label__ = 85; break; } else { __label__ = 84; break; } + case 84: + var $376=$framenum; + var $377=$376; + var $378=$377; + var $379=(($378+8)|0); + var $380=HEAP32[(($379)>>2)]; + var $381=$framenum; + var $382=$381; + FUNCTION_TABLE[$380]($382); + __label__ = 85; break; + case 85: + __label__ = 86; break; + case 86: + $1=0; + __label__ = 198; break; + case 87: + $has_frame_think=1; + __label__ = 88; break; + case 88: + var $387=$2; + var $388=(($387)|0); + var $389=HEAP32[(($388)>>2)]; + var $390=(($389+292)|0); + var $391=(($390+28)|0); + var $392=(($391)|0); + var $393=HEAP32[(($392)>>2)]; + var $394=(($391+4)|0); + var $395=HEAP32[(($394)>>2)]; + var $396=_ast_block_new($393, $395); + $block=$396; + var $397=$block; + var $398=(($397)|0)!=0; + if ($398) { __label__ = 100; break; } else { __label__ = 89; break; } + case 89: + var $400=$2; + _parseerror($400, ((STRING_TABLE.__str122694)|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)); + var $401=$has_frame_think; + var $402=(($401) & 1); + if ($402) { __label__ = 90; break; } else { __label__ = 99; break; } + case 90: + __label__ = 91; break; + case 91: + var $405=$nextthink; + var $406=$405; + var $407=$406; + var $408=(($407+16)|0); + var $409=HEAP8[($408)]; + var $410=(($409) & 1); + if ($410) { __label__ = 93; break; } else { __label__ = 92; break; } + case 92: + var $412=$nextthink; + var $413=$412; + var $414=$413; + var $415=(($414+8)|0); + var $416=HEAP32[(($415)>>2)]; + var $417=$nextthink; + var $418=$417; + FUNCTION_TABLE[$416]($418); + __label__ = 93; break; + case 93: + __label__ = 94; break; + case 94: + __label__ = 95; break; + case 95: + var $422=$framenum; + var $423=$422; + var $424=$423; + var $425=(($424+16)|0); + var $426=HEAP8[($425)]; + var $427=(($426) & 1); + if ($427) { __label__ = 97; break; } else { __label__ = 96; break; } + case 96: + var $429=$framenum; + var $430=$429; + var $431=$430; + var $432=(($431+8)|0); + var $433=HEAP32[(($432)>>2)]; + var $434=$framenum; + var $435=$434; + FUNCTION_TABLE[$433]($435); + __label__ = 97; break; + case 97: + __label__ = 98; break; + case 98: + __label__ = 99; break; + case 99: + $1=0; + __label__ = 198; break; + case 100: + var $440=$has_frame_think; + var $441=(($440) & 1); + if ($441) { __label__ = 101; break; } else { __label__ = 150; break; } + case 101: + var $443=$2; + var $444=(($443)|0); + var $445=HEAP32[(($444)>>2)]; + var $446=(($445+292)|0); + var $447=(($446+28)|0); + var $448=$ctx; + var $449=$447; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($448)>>2)]=HEAP32[(($449)>>2)];HEAP32[((($448)+(4))>>2)]=HEAP32[((($449)+(4))>>2)]; + var $450=$gbl_self; + var $451=$fld_frame; + var $452=(($ctx)|0); + var $453=HEAP32[(($452)>>2)]; + var $454=(($ctx+4)|0); + var $455=HEAP32[(($454)>>2)]; + var $456=_ast_entfield_new($453, $455, $450, $451); + var $457=$456; + $self_frame=$457; + var $458=$gbl_self; + var $459=$fld_nextthink; + var $460=(($ctx)|0); + var $461=HEAP32[(($460)>>2)]; + var $462=(($ctx+4)|0); + var $463=HEAP32[(($462)>>2)]; + var $464=_ast_entfield_new($461, $463, $458, $459); + var $465=$464; + $self_nextthink=$465; + var $466=$gbl_self; + var $467=$fld_think; + var $468=(($ctx)|0); + var $469=HEAP32[(($468)>>2)]; + var $470=(($ctx+4)|0); + var $471=HEAP32[(($470)>>2)]; + var $472=_ast_entfield_new($469, $471, $466, $467); + var $473=$472; + $self_think=$473; + var $474=$gbl_time; + var $475=$2; + var $476=_parser_const_float($475, 0.1); + var $477=$476; + var $478=(($ctx)|0); + var $479=HEAP32[(($478)>>2)]; + var $480=(($ctx+4)|0); + var $481=HEAP32[(($480)>>2)]; + var $482=_ast_binary_new($479, $481, 6, $474, $477); + var $483=$482; + $time_plus_1=$483; + var $484=$self_frame; + var $485=(($484)|0)!=0; + if ($485) { __label__ = 102; break; } else { __label__ = 105; break; } + case 102: + var $487=$self_nextthink; + var $488=(($487)|0)!=0; + if ($488) { __label__ = 103; break; } else { __label__ = 105; break; } + case 103: + var $490=$self_think; + var $491=(($490)|0)!=0; + if ($491) { __label__ = 104; break; } else { __label__ = 105; break; } + case 104: + var $493=$time_plus_1; + var $494=(($493)|0)!=0; + if ($494) { __label__ = 114; break; } else { __label__ = 105; break; } + case 105: + var $496=$self_frame; + var $497=(($496)|0)!=0; + if ($497) { __label__ = 106; break; } else { __label__ = 107; break; } + case 106: + var $499=$self_frame; + var $500=$499; + var $501=$500; + var $502=(($501+8)|0); + var $503=HEAP32[(($502)>>2)]; + var $504=$self_frame; + var $505=$504; + FUNCTION_TABLE[$503]($505); + __label__ = 107; break; + case 107: + var $507=$self_nextthink; + var $508=(($507)|0)!=0; + if ($508) { __label__ = 108; break; } else { __label__ = 109; break; } + case 108: + var $510=$self_nextthink; + var $511=$510; + var $512=$511; + var $513=(($512+8)|0); + var $514=HEAP32[(($513)>>2)]; + var $515=$self_nextthink; + var $516=$515; + FUNCTION_TABLE[$514]($516); + __label__ = 109; break; + case 109: + var $518=$self_think; + var $519=(($518)|0)!=0; + if ($519) { __label__ = 110; break; } else { __label__ = 111; break; } + case 110: + var $521=$self_think; + var $522=$521; + var $523=$522; + var $524=(($523+8)|0); + var $525=HEAP32[(($524)>>2)]; + var $526=$self_think; + var $527=$526; + FUNCTION_TABLE[$525]($527); + __label__ = 111; break; + case 111: + var $529=$time_plus_1; + var $530=(($529)|0)!=0; + if ($530) { __label__ = 112; break; } else { __label__ = 113; break; } + case 112: + var $532=$time_plus_1; + var $533=$532; + var $534=$533; + var $535=(($534+8)|0); + var $536=HEAP32[(($535)>>2)]; + var $537=$time_plus_1; + var $538=$537; + FUNCTION_TABLE[$536]($538); + __label__ = 113; break; + case 113: + $retval=0; + __label__ = 114; break; + case 114: + var $541=$retval; + var $542=(($541) & 1); + if ($542) { __label__ = 115; break; } else { __label__ = 139; break; } + case 115: + var $544=$self_frame; + var $545=$framenum; + var $546=(($ctx)|0); + var $547=HEAP32[(($546)>>2)]; + var $548=(($ctx+4)|0); + var $549=HEAP32[(($548)>>2)]; + var $550=_ast_store_new($547, $549, 37, $544, $545); + $store_frame=$550; + var $551=$self_nextthink; + var $552=$time_plus_1; + var $553=(($ctx)|0); + var $554=HEAP32[(($553)>>2)]; + var $555=(($ctx+4)|0); + var $556=HEAP32[(($555)>>2)]; + var $557=_ast_store_new($554, $556, 37, $551, $552); + $store_nextthink=$557; + var $558=$self_think; + var $559=$nextthink; + var $560=(($ctx)|0); + var $561=HEAP32[(($560)>>2)]; + var $562=(($ctx+4)|0); + var $563=HEAP32[(($562)>>2)]; + var $564=_ast_store_new($561, $563, 42, $558, $559); + $store_think=$564; + var $565=$store_frame; + var $566=(($565)|0)!=0; + if ($566) { __label__ = 117; break; } else { __label__ = 116; break; } + case 116: + var $568=$self_frame; + var $569=$568; + var $570=$569; + var $571=(($570+8)|0); + var $572=HEAP32[(($571)>>2)]; + var $573=$self_frame; + var $574=$573; + FUNCTION_TABLE[$572]($574); + $retval=0; + __label__ = 117; break; + case 117: + var $576=$store_nextthink; + var $577=(($576)|0)!=0; + if ($577) { __label__ = 119; break; } else { __label__ = 118; break; } + case 118: + var $579=$self_nextthink; + var $580=$579; + var $581=$580; + var $582=(($581+8)|0); + var $583=HEAP32[(($582)>>2)]; + var $584=$self_nextthink; + var $585=$584; + FUNCTION_TABLE[$583]($585); + $retval=0; + __label__ = 119; break; + case 119: + var $587=$store_think; + var $588=(($587)|0)!=0; + if ($588) { __label__ = 121; break; } else { __label__ = 120; break; } + case 120: + var $590=$self_think; + var $591=$590; + var $592=$591; + var $593=(($592+8)|0); + var $594=HEAP32[(($593)>>2)]; + var $595=$self_think; + var $596=$595; + FUNCTION_TABLE[$594]($596); + $retval=0; + __label__ = 121; break; + case 121: + var $598=$retval; + var $599=(($598) & 1); + if ($599) { __label__ = 129; break; } else { __label__ = 122; break; } + case 122: + var $601=$store_frame; + var $602=(($601)|0)!=0; + if ($602) { __label__ = 123; break; } else { __label__ = 124; break; } + case 123: + var $604=$store_frame; + var $605=$604; + var $606=$605; + var $607=(($606+8)|0); + var $608=HEAP32[(($607)>>2)]; + var $609=$store_frame; + var $610=$609; + FUNCTION_TABLE[$608]($610); + __label__ = 124; break; + case 124: + var $612=$store_nextthink; + var $613=(($612)|0)!=0; + if ($613) { __label__ = 125; break; } else { __label__ = 126; break; } + case 125: + var $615=$store_nextthink; + var $616=$615; + var $617=$616; + var $618=(($617+8)|0); + var $619=HEAP32[(($618)>>2)]; + var $620=$store_nextthink; + var $621=$620; + FUNCTION_TABLE[$619]($621); + __label__ = 126; break; + case 126: + var $623=$store_think; + var $624=(($623)|0)!=0; + if ($624) { __label__ = 127; break; } else { __label__ = 128; break; } + case 127: + var $626=$store_think; + var $627=$626; + var $628=$627; + var $629=(($628+8)|0); + var $630=HEAP32[(($629)>>2)]; + var $631=$store_think; + var $632=$631; + FUNCTION_TABLE[$630]($632); + __label__ = 128; break; + case 128: + $retval=0; + __label__ = 129; break; + case 129: + var $635=$retval; + var $636=(($635) & 1); + if ($636) { __label__ = 130; break; } else { __label__ = 132; break; } + case 130: + var $638=$block; + var $639=$store_frame; + var $640=$639; + var $641=_ast_block_exprs_add($638, $640); + if ($641) { __label__ = 132; break; } else { __label__ = 131; break; } + case 131: + var $643=$store_frame; + var $644=$643; + var $645=$644; + var $646=(($645+8)|0); + var $647=HEAP32[(($646)>>2)]; + var $648=$store_frame; + var $649=$648; + FUNCTION_TABLE[$647]($649); + var $650=$store_nextthink; + var $651=$650; + var $652=$651; + var $653=(($652+8)|0); + var $654=HEAP32[(($653)>>2)]; + var $655=$store_nextthink; + var $656=$655; + FUNCTION_TABLE[$654]($656); + var $657=$store_think; + var $658=$657; + var $659=$658; + var $660=(($659+8)|0); + var $661=HEAP32[(($660)>>2)]; + var $662=$store_think; + var $663=$662; + FUNCTION_TABLE[$661]($663); + $retval=0; + __label__ = 132; break; + case 132: + var $665=$retval; + var $666=(($665) & 1); + if ($666) { __label__ = 133; break; } else { __label__ = 135; break; } + case 133: + var $668=$block; + var $669=$store_nextthink; + var $670=$669; + var $671=_ast_block_exprs_add($668, $670); + if ($671) { __label__ = 135; break; } else { __label__ = 134; break; } + case 134: + var $673=$store_nextthink; + var $674=$673; + var $675=$674; + var $676=(($675+8)|0); + var $677=HEAP32[(($676)>>2)]; + var $678=$store_nextthink; + var $679=$678; + FUNCTION_TABLE[$677]($679); + var $680=$store_think; + var $681=$680; + var $682=$681; + var $683=(($682+8)|0); + var $684=HEAP32[(($683)>>2)]; + var $685=$store_think; + var $686=$685; + FUNCTION_TABLE[$684]($686); + $retval=0; + __label__ = 135; break; + case 135: + var $688=$retval; + var $689=(($688) & 1); + if ($689) { __label__ = 136; break; } else { __label__ = 138; break; } + case 136: + var $691=$block; + var $692=$store_think; + var $693=$692; + var $694=_ast_block_exprs_add($691, $693); + if ($694) { __label__ = 138; break; } else { __label__ = 137; break; } + case 137: + var $696=$store_think; + var $697=$696; + var $698=$697; + var $699=(($698+8)|0); + var $700=HEAP32[(($699)>>2)]; + var $701=$store_think; + var $702=$701; + FUNCTION_TABLE[$700]($702); + $retval=0; + __label__ = 138; break; + case 138: + __label__ = 139; break; + case 139: + var $705=$retval; + var $706=(($705) & 1); + if ($706) { __label__ = 149; break; } else { __label__ = 140; break; } + case 140: + var $708=$2; + _parseerror($708, ((STRING_TABLE.__str123695)|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)); + __label__ = 141; break; + case 141: + var $710=$nextthink; + var $711=$710; + var $712=$711; + var $713=(($712+16)|0); + var $714=HEAP8[($713)]; + var $715=(($714) & 1); + if ($715) { __label__ = 143; break; } else { __label__ = 142; break; } + case 142: + var $717=$nextthink; + var $718=$717; + var $719=$718; + var $720=(($719+8)|0); + var $721=HEAP32[(($720)>>2)]; + var $722=$nextthink; + var $723=$722; + FUNCTION_TABLE[$721]($723); + __label__ = 143; break; + case 143: + __label__ = 144; break; + case 144: + __label__ = 145; break; + case 145: + var $727=$framenum; + var $728=$727; + var $729=$728; + var $730=(($729+16)|0); + var $731=HEAP8[($730)]; + var $732=(($731) & 1); + if ($732) { __label__ = 147; break; } else { __label__ = 146; break; } + case 146: + var $734=$framenum; + var $735=$734; + var $736=$735; + var $737=(($736+8)|0); + var $738=HEAP32[(($737)>>2)]; + var $739=$framenum; + var $740=$739; + FUNCTION_TABLE[$738]($740); + __label__ = 147; break; + case 147: + __label__ = 148; break; + case 148: + var $743=$block; + var $744=$743; + var $745=$744; + var $746=(($745+8)|0); + var $747=HEAP32[(($746)>>2)]; + var $748=$block; + var $749=$748; + FUNCTION_TABLE[$747]($749); + $1=0; + __label__ = 198; break; + case 149: + __label__ = 150; break; + case 150: + $parami=0; + __label__ = 151; break; + case 151: + var $753=$parami; + var $754=$3; + var $755=(($754)|0); + var $756=(($755+36)|0); + var $757=HEAP32[(($756)>>2)]; + var $758=(($753)>>>0) < (($757)>>>0); + if ($758) { __label__ = 152; break; } else { __label__ = 173; break; } + case 152: + var $760=$parami; + var $761=$3; + var $762=(($761)|0); + var $763=(($762+32)|0); + var $764=HEAP32[(($763)>>2)]; + var $765=(($764+($760<<2))|0); + var $766=HEAP32[(($765)>>2)]; + $param=$766; + var $767=$param; + var $768=(($767)|0); + var $769=(($768+24)|0); + var $770=HEAP32[(($769)>>2)]; + var $771=(($770)|0)!=3; + if ($771) { __label__ = 153; break; } else { __label__ = 156; break; } + case 153: + var $773=$param; + var $774=(($773)|0); + var $775=(($774+24)|0); + var $776=HEAP32[(($775)>>2)]; + var $777=(($776)|0)!=5; + if ($777) { __label__ = 155; break; } else { __label__ = 154; break; } + case 154: + var $779=$param; + var $780=(($779)|0); + var $781=(($780+28)|0); + var $782=HEAP32[(($781)>>2)]; + var $783=$782; + var $784=(($783+24)|0); + var $785=HEAP32[(($784)>>2)]; + var $786=(($785)|0)!=3; + if ($786) { __label__ = 155; break; } else { __label__ = 156; break; } + case 155: + __label__ = 172; break; + case 156: + var $789=$2; + var $790=$param; + var $791=(($ve)|0); + var $792=_create_vector_members($789, $790, $791); + if ($792) { __label__ = 158; break; } else { __label__ = 157; break; } + case 157: + var $794=$block; + _ast_block_delete($794); + $1=0; + __label__ = 198; break; + case 158: + $e=0; + __label__ = 159; break; + case 159: + var $797=$e; + var $798=(($797)>>>0) < 3; + if ($798) { __label__ = 160; break; } else { __label__ = 166; break; } + case 160: + var $800=$2; + var $801=$e; + var $802=(($ve+($801<<3))|0); + var $803=(($802)|0); + var $804=HEAP32[(($803)>>2)]; + var $805=(($802+4)|0); + var $806=HEAP32[(($805)>>2)]; + var $807=_parser_t_locals_add($800, $804, $806); + if ($807) { __label__ = 162; break; } else { __label__ = 161; break; } + case 161: + __label__ = 166; break; + case 162: + var $810=$block; + var $811=$e; + var $812=(($ve+($811<<3))|0); + var $813=(($812+4)|0); + var $814=HEAP32[(($813)>>2)]; + var $815=_ast_block_collect($810, $814); + if ($815) { __label__ = 164; break; } else { __label__ = 163; break; } + case 163: + var $817=$2; + var $818=(($817+104)|0); + var $819=HEAP32[(($818)>>2)]; + var $820=((($819)-(1))|0); + HEAP32[(($818)>>2)]=$820; + __label__ = 166; break; + case 164: + var $822=$e; + var $823=(($ve+($822<<3))|0); + var $824=(($823+4)|0); + HEAP32[(($824)>>2)]=0; + __label__ = 165; break; + case 165: + var $826=$e; + var $827=((($826)+(1))|0); + $e=$827; + __label__ = 159; break; + case 166: + var $829=$e; + var $830=(($829)|0)!=3; + if ($830) { __label__ = 167; break; } else { __label__ = 171; break; } + case 167: + var $832=$e; + var $833=$2; + var $834=(($833+100)|0); + var $835=HEAP32[(($834)>>2)]; + var $836=(((-$832))|0); + var $837=(($835+($836<<3))|0); + HEAP32[(($834)>>2)]=$837; + __label__ = 168; break; + case 168: + var $839=$e; + var $840=(($ve+($839<<3))|0); + var $841=(($840)|0); + var $842=HEAP32[(($841)>>2)]; + _util_memory_d($842, 2225, ((STRING_TABLE.__str572)|0)); + var $843=$e; + var $844=((($843)-(1))|0); + $e=$844; + __label__ = 169; break; + case 169: + var $846=$e; + var $847=(($846)|0)!=0; + if ($847) { __label__ = 168; break; } else { __label__ = 170; break; } + case 170: + var $849=$block; + _ast_block_delete($849); + $1=0; + __label__ = 198; break; + case 171: + __label__ = 172; break; + case 172: + var $852=$parami; + var $853=((($852)+(1))|0); + $parami=$853; + __label__ = 151; break; + case 173: + var $855=$3; + var $856=$855; + var $857=(($856)|0); + var $858=$3; + var $859=(($858+56)|0); + var $860=HEAP32[(($859)>>2)]; + var $861=$3; + var $862=(($857)|0); + var $863=HEAP32[(($862)>>2)]; + var $864=(($857+4)|0); + var $865=HEAP32[(($864)>>2)]; + var $866=_ast_function_new($863, $865, $860, $861); + $func=$866; + var $867=$func; + var $868=(($867)|0)!=0; + if ($868) { __label__ = 175; break; } else { __label__ = 174; break; } + case 174: + var $870=$2; + var $871=$3; + var $872=(($871+56)|0); + var $873=HEAP32[(($872)>>2)]; + _parseerror($870, ((STRING_TABLE.__str53625)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$873,tempInt)); + var $874=$block; + _ast_block_delete($874); + __label__ = 194; break; + case 175: + var $876=$2; + var $877=$func; + var $878=_parser_t_functions_add($876, $877); + if ($878) { __label__ = 177; break; } else { __label__ = 176; break; } + case 176: + var $880=$2; + var $881=$3; + var $882=(($881+56)|0); + var $883=HEAP32[(($882)>>2)]; + _parseerror($880, ((STRING_TABLE.__str54626)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$883,tempInt)); + var $884=$block; + _ast_block_delete($884); + __label__ = 193; break; + case 177: + var $886=$func; + var $887=$2; + var $888=(($887+96)|0); + HEAP32[(($888)>>2)]=$886; + var $889=$2; + var $890=$block; + var $891=_parse_block_into($889, $890, 1); + if ($891) { __label__ = 179; break; } else { __label__ = 178; break; } + case 178: + var $893=$block; + _ast_block_delete($893); + __label__ = 192; break; + case 179: + var $895=$func; + var $896=$block; + var $897=_ast_function_blocks_add($895, $896); + if ($897) { __label__ = 181; break; } else { __label__ = 180; break; } + case 180: + var $899=$block; + _ast_block_delete($899); + __label__ = 192; break; + case 181: + var $901=$old; + var $902=$2; + var $903=(($902+96)|0); + HEAP32[(($903)>>2)]=$901; + __label__ = 182; break; + case 182: + var $905=$2; + var $906=(($905+104)|0); + var $907=HEAP32[(($906)>>2)]; + var $908=(($907)|0)!=0; + if ($908) { __label__ = 183; break; } else { __label__ = 186; break; } + case 183: + var $910=$retval; + var $911=(($910) & 1); + if ($911) { __label__ = 184; break; } else { var $916 = 0;__label__ = 185; break; } + case 184: + var $913=$2; + var $914=_parser_pop_local($913); + var $916 = $914;__label__ = 185; break; + case 185: + var $916; + var $917=(($916)&1); + $retval=$917; + __label__ = 182; break; + case 186: + var $919=$2; + var $920=(($919+4)|0); + var $921=HEAP32[(($920)>>2)]; + var $922=(($921)|0)==59; + if ($922) { __label__ = 187; break; } else { __label__ = 188; break; } + case 187: + var $924=$2; + var $925=_parser_next($924); + $1=$925; + __label__ = 198; break; + case 188: + var $927=HEAP32[((_opts_standard)>>2)]; + var $928=(($927)|0)==0; + if ($928) { __label__ = 189; break; } else { __label__ = 190; break; } + case 189: + var $930=$2; + _parseerror($930, ((STRING_TABLE.__str124696)|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)); + __label__ = 190; break; + case 190: + __label__ = 191; break; + case 191: + var $933=$retval; + var $934=(($933) & 1); + $1=$934; + __label__ = 198; break; + case 192: + var $936=$2; + var $937=(($936+36)|0); + var $938=HEAP32[(($937)>>2)]; + var $939=((($938)-(1))|0); + HEAP32[(($937)>>2)]=$939; + __label__ = 193; break; + case 193: + var $941=$func; + _ast_function_delete($941); + var $942=$3; + var $943=(($942+64)|0); + var $944=$943; + HEAP32[(($944)>>2)]=0; + __label__ = 194; break; + case 194: + __label__ = 195; break; + case 195: + var $947=$2; + var $948=(($947+104)|0); + var $949=HEAP32[(($948)>>2)]; + var $950=(($949)|0)!=0; + if ($950) { __label__ = 196; break; } else { __label__ = 197; break; } + case 196: + var $952=$2; + var $953=(($952+104)|0); + var $954=HEAP32[(($953)>>2)]; + var $955=((($954)-(1))|0); + HEAP32[(($953)>>2)]=$955; + var $956=$2; + var $957=(($956+104)|0); + var $958=HEAP32[(($957)>>2)]; + var $959=$2; + var $960=(($959+100)|0); + var $961=HEAP32[(($960)>>2)]; + var $962=(($961+($958<<3))|0); + var $963=(($962)|0); + var $964=HEAP32[(($963)>>2)]; + _util_memory_d($964, 2275, ((STRING_TABLE.__str572)|0)); + __label__ = 195; break; + case 197: + var $966=$old; + var $967=$2; + var $968=(($967+96)|0); + HEAP32[(($968)>>2)]=$966; + $1=0; + __label__ = 198; break; + case 198: + var $970=$1; + STACKTOP = __stackBase__; + return $970; + default: assert(0, "bad label: " + __label__); + } +} +_parse_function_body["X"]=1; + +function _parse_expression_leave($parser, $stopatcomma) { + var __stackBase__ = STACKTOP; STACKTOP += 248; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $expr; + var $sy=__stackBase__; + var $wantop; + var $gotmemberof; + var $parens; + var $var; + var $4=(__stackBase__)+(24); + var $val; + var $5=(__stackBase__)+(52); + var $val1; + var $6=(__stackBase__)+(80); + var $val2; + var $7=(__stackBase__)+(108); + var $val3; + var $8=(__stackBase__)+(136); + var $op; + var $olast; + var $o; + var $prevex; + var $9=(__stackBase__)+(164); + var $10=(__stackBase__)+(192); + var $11=(__stackBase__)+(220); + $2=$parser; + var $12=(($stopatcomma)&1); + $3=$12; + $expr=0; + $wantop=0; + $gotmemberof=0; + $parens=0; + var $13=(($sy)|0); + HEAP32[(($13)>>2)]=0; + var $14=(($sy+4)|0); + HEAP32[(($14)>>2)]=0; + var $15=(($sy+8)|0); + HEAP32[(($15)>>2)]=0; + var $16=(($sy+12)|0); + HEAP32[(($16)>>2)]=0; + var $17=(($sy+16)|0); + HEAP32[(($17)>>2)]=0; + var $18=(($sy+20)|0); + HEAP32[(($18)>>2)]=0; + var $19=$2; + var $20=(($19)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21+328)|0); + var $23=(($22)|0); + HEAP8[($23)]=0; + var $24=$2; + _parser_reclassify_token($24); + __label__ = 3; break; + case 3: + var $26=$gotmemberof; + var $27=(($26) & 1); + if ($27) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $gotmemberof=0; + __label__ = 6; break; + case 5: + var $30=$2; + var $31=(($30+120)|0); + HEAP32[(($31)>>2)]=0; + __label__ = 6; break; + case 6: + var $33=$2; + var $34=(($33+4)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)==129; + if ($36) { __label__ = 7; break; } else { __label__ = 32; break; } + case 7: + var $38=$wantop; + var $39=(($38) & 1); + if ($39) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $41=$2; + _parseerror($41, ((STRING_TABLE.__str57629)|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)); + __label__ = 165; break; + case 9: + $wantop=1; + var $43=HEAP32[((_opts_standard)>>2)]; + var $44=(($43)|0)==3; + if ($44) { __label__ = 10; break; } else { __label__ = 22; break; } + case 10: + var $46=$2; + var $47=(($46+120)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48)|0)==4; + if ($49) { __label__ = 11; break; } else { __label__ = 14; break; } + case 11: + var $51=$2; + var $52=$2; + var $53=(($52)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=(($54+292)|0); + var $56=(($55+4)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=_parser_find_var($51, $57); + $var=$58; + var $59=$var; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + var $62=$2; + var $63=$2; + var $64=(($63)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($65+292)|0); + var $67=(($66+4)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=_parser_find_field($62, $68); + $var=$69; + __label__ = 13; break; + case 13: + __label__ = 21; break; + case 14: + var $72=$2; + var $73=(($72+120)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($74)|0)==3; + if ($75) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $77=$2; + _parseerror($77, ((STRING_TABLE.__str58630)|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)); + __label__ = 165; break; + case 16: + var $79=$2; + var $80=(($79+120)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81)|0)!=0; + if ($82) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $84=$2; + _parseerror($84, ((STRING_TABLE.__str59631)|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)); + __label__ = 165; break; + case 18: + var $86=$2; + var $87=$2; + var $88=(($87)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($89+292)|0); + var $91=(($90+4)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=_parser_find_var($86, $92); + $var=$93; + __label__ = 19; break; + case 19: + __label__ = 20; break; + case 20: + __label__ = 21; break; + case 21: + __label__ = 25; break; + case 22: + var $98=$2; + var $99=$2; + var $100=(($99)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=(($101+292)|0); + var $103=(($102+4)|0); + var $104=HEAP32[(($103)>>2)]; + var $105=_parser_find_var($98, $104); + $var=$105; + var $106=$var; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $109=$2; + var $110=$2; + var $111=(($110)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($112+292)|0); + var $114=(($113+4)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=_parser_find_field($109, $115); + $var=$116; + __label__ = 24; break; + case 24: + __label__ = 25; break; + case 25: + var $119=$var; + var $120=(($119)|0)!=0; + if ($120) { __label__ = 27; break; } else { __label__ = 26; break; } + case 26: + var $122=$2; + var $123=$2; + var $124=(($123)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=(($125+292)|0); + var $127=(($126+4)|0); + var $128=HEAP32[(($127)>>2)]; + _parseerror($122, ((STRING_TABLE.__str60632)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$128,tempInt)); + __label__ = 165; break; + case 27: + var $130=$var; + var $131=$130; + var $132=(($131+12)|0); + var $133=HEAP32[(($132)>>2)]; + var $134=(($133)|0)==2; + if ($134) { __label__ = 28; break; } else { __label__ = 29; break; } + case 28: + var $136=$var; + var $137=$136; + var $138=(($137+76)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=((($139)+(1))|0); + HEAP32[(($138)>>2)]=$140; + __label__ = 29; break; + case 29: + var $142=$2; + var $143=(($142)|0); + var $144=HEAP32[(($143)>>2)]; + var $145=(($144+292)|0); + var $146=(($145+28)|0); + var $147=$var; + var $148=(($146)|0); + var $149=HEAP32[(($148)>>2)]; + var $150=(($146+4)|0); + var $151=HEAP32[(($150)>>2)]; + _syexp($4, $149, $151, $147); + var $152=_shunt_out_add($sy, $4); + if ($152) { __label__ = 31; break; } else { __label__ = 30; break; } + case 30: + var $154=$2; + _parseerror($154, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 31: + __label__ = 146; break; + case 32: + var $157=$2; + var $158=(($157+4)|0); + var $159=HEAP32[(($158)>>2)]; + var $160=(($159)|0)==138; + if ($160) { __label__ = 33; break; } else { __label__ = 40; break; } + case 33: + var $162=$wantop; + var $163=(($162) & 1); + if ($163) { __label__ = 34; break; } else { __label__ = 35; break; } + case 34: + var $165=$2; + _parseerror($165, ((STRING_TABLE.__str62634)|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)); + __label__ = 165; break; + case 35: + $wantop=1; + var $167=$2; + var $168=$2; + var $169=(($168)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=(($170+292)|0); + var $172=(($171+16)|0); + var $173=$172; + var $174=(tempDoubleI32[0]=HEAP32[(($173)>>2)],tempDoubleI32[1]=HEAP32[((($173)+(4))>>2)],tempDoubleF64[0]); + var $175=_parser_const_float($167, $174); + $val=$175; + var $176=$val; + var $177=(($176)|0)!=0; + if ($177) { __label__ = 37; break; } else { __label__ = 36; break; } + case 36: + $1=0; + __label__ = 170; break; + case 37: + var $180=$2; + var $181=(($180)|0); + var $182=HEAP32[(($181)>>2)]; + var $183=(($182+292)|0); + var $184=(($183+28)|0); + var $185=$val; + var $186=$185; + var $187=(($184)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=(($184+4)|0); + var $190=HEAP32[(($189)>>2)]; + _syexp($5, $188, $190, $186); + var $191=_shunt_out_add($sy, $5); + if ($191) { __label__ = 39; break; } else { __label__ = 38; break; } + case 38: + var $193=$2; + _parseerror($193, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 39: + __label__ = 145; break; + case 40: + var $196=$2; + var $197=(($196+4)|0); + var $198=HEAP32[(($197)>>2)]; + var $199=(($198)|0)==137; + if ($199) { __label__ = 41; break; } else { __label__ = 48; break; } + case 41: + var $201=$wantop; + var $202=(($201) & 1); + if ($202) { __label__ = 42; break; } else { __label__ = 43; break; } + case 42: + var $204=$2; + _parseerror($204, ((STRING_TABLE.__str62634)|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)); + __label__ = 165; break; + case 43: + $wantop=1; + var $206=$2; + var $207=$2; + var $208=(($207)|0); + var $209=HEAP32[(($208)>>2)]; + var $210=(($209+292)|0); + var $211=(($210+16)|0); + var $212=$211; + var $213=HEAP32[(($212)>>2)]; + var $214=(($213)|0); + var $215=_parser_const_float($206, $214); + $val1=$215; + var $216=$val1; + var $217=(($216)|0)!=0; + if ($217) { __label__ = 45; break; } else { __label__ = 44; break; } + case 44: + $1=0; + __label__ = 170; break; + case 45: + var $220=$2; + var $221=(($220)|0); + var $222=HEAP32[(($221)>>2)]; + var $223=(($222+292)|0); + var $224=(($223+28)|0); + var $225=$val1; + var $226=$225; + var $227=(($224)|0); + var $228=HEAP32[(($227)>>2)]; + var $229=(($224+4)|0); + var $230=HEAP32[(($229)>>2)]; + _syexp($6, $228, $230, $226); + var $231=_shunt_out_add($sy, $6); + if ($231) { __label__ = 47; break; } else { __label__ = 46; break; } + case 46: + var $233=$2; + _parseerror($233, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 47: + __label__ = 144; break; + case 48: + var $236=$2; + var $237=(($236+4)|0); + var $238=HEAP32[(($237)>>2)]; + var $239=(($238)|0)==134; + if ($239) { __label__ = 49; break; } else { __label__ = 56; break; } + case 49: + var $241=$wantop; + var $242=(($241) & 1); + if ($242) { __label__ = 50; break; } else { __label__ = 51; break; } + case 50: + var $244=$2; + _parseerror($244, ((STRING_TABLE.__str62634)|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)); + __label__ = 165; break; + case 51: + $wantop=1; + var $246=$2; + var $247=$2; + var $248=(($247)|0); + var $249=HEAP32[(($248)>>2)]; + var $250=(($249+292)|0); + var $251=(($250+4)|0); + var $252=HEAP32[(($251)>>2)]; + var $253=_parser_const_string($246, $252); + $val2=$253; + var $254=$val2; + var $255=(($254)|0)!=0; + if ($255) { __label__ = 53; break; } else { __label__ = 52; break; } + case 52: + $1=0; + __label__ = 170; break; + case 53: + var $258=$2; + var $259=(($258)|0); + var $260=HEAP32[(($259)>>2)]; + var $261=(($260+292)|0); + var $262=(($261+28)|0); + var $263=$val2; + var $264=$263; + var $265=(($262)|0); + var $266=HEAP32[(($265)>>2)]; + var $267=(($262+4)|0); + var $268=HEAP32[(($267)>>2)]; + _syexp($7, $266, $268, $264); + var $269=_shunt_out_add($sy, $7); + if ($269) { __label__ = 55; break; } else { __label__ = 54; break; } + case 54: + var $271=$2; + _parseerror($271, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 55: + __label__ = 143; break; + case 56: + var $274=$2; + var $275=(($274+4)|0); + var $276=HEAP32[(($275)>>2)]; + var $277=(($276)|0)==136; + if ($277) { __label__ = 57; break; } else { __label__ = 64; break; } + case 57: + var $279=$wantop; + var $280=(($279) & 1); + if ($280) { __label__ = 58; break; } else { __label__ = 59; break; } + case 58: + var $282=$2; + _parseerror($282, ((STRING_TABLE.__str62634)|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)); + __label__ = 165; break; + case 59: + $wantop=1; + var $284=$2; + var $285=$2; + var $286=(($285)|0); + var $287=HEAP32[(($286)>>2)]; + var $288=(($287+292)|0); + var $289=(($288+16)|0); + var $290=$289; + var $291=(($290)|0); + var $292=HEAPF32[(($291)>>2)]; + var $293=(($290+4)|0); + var $294=HEAPF32[(($293)>>2)]; + var $295=(($290+8)|0); + var $296=HEAPF32[(($295)>>2)]; + var $297=_parser_const_vector($284, $292, $294, $296); + $val3=$297; + var $298=$val3; + var $299=(($298)|0)!=0; + if ($299) { __label__ = 61; break; } else { __label__ = 60; break; } + case 60: + $1=0; + __label__ = 170; break; + case 61: + var $302=$2; + var $303=(($302)|0); + var $304=HEAP32[(($303)>>2)]; + var $305=(($304+292)|0); + var $306=(($305+28)|0); + var $307=$val3; + var $308=$307; + var $309=(($306)|0); + var $310=HEAP32[(($309)>>2)]; + var $311=(($306+4)|0); + var $312=HEAP32[(($311)>>2)]; + _syexp($8, $310, $312, $308); + var $313=_shunt_out_add($sy, $8); + if ($313) { __label__ = 63; break; } else { __label__ = 62; break; } + case 62: + var $315=$2; + _parseerror($315, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 63: + __label__ = 142; break; + case 64: + var $318=$2; + var $319=(($318+4)|0); + var $320=HEAP32[(($319)>>2)]; + var $321=(($320)|0)==40; + if ($321) { __label__ = 65; break; } else { __label__ = 66; break; } + case 65: + var $323=$2; + _parseerror($323, ((STRING_TABLE.__str63635)|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)); + __label__ = 165; break; + case 66: + var $325=$2; + var $326=(($325+4)|0); + var $327=HEAP32[(($326)>>2)]; + var $328=(($327)|0)==41; + if ($328) { __label__ = 67; break; } else { __label__ = 79; break; } + case 67: + var $330=$wantop; + var $331=(($330) & 1); + if ($331) { __label__ = 68; break; } else { __label__ = 73; break; } + case 68: + var $333=$parens; + var $334=((($333)-(1))|0); + $parens=$334; + var $335=$parens; + var $336=(($335)|0) < 0; + if ($336) { __label__ = 69; break; } else { __label__ = 70; break; } + case 69: + __label__ = 152; break; + case 70: + var $339=$2; + var $340=_parser_close_paren($339, $sy, 0); + if ($340) { __label__ = 72; break; } else { __label__ = 71; break; } + case 71: + __label__ = 165; break; + case 72: + __label__ = 78; break; + case 73: + var $344=$parens; + var $345=((($344)-(1))|0); + $parens=$345; + var $346=$parens; + var $347=(($346)|0) < 0; + if ($347) { __label__ = 74; break; } else { __label__ = 75; break; } + case 74: + __label__ = 152; break; + case 75: + var $350=$2; + var $351=_parser_close_paren($350, $sy, 1); + if ($351) { __label__ = 77; break; } else { __label__ = 76; break; } + case 76: + __label__ = 165; break; + case 77: + __label__ = 78; break; + case 78: + $wantop=1; + __label__ = 140; break; + case 79: + var $356=$2; + var $357=(($356+4)|0); + var $358=HEAP32[(($357)>>2)]; + var $359=(($358)|0)!=131; + if ($359) { __label__ = 80; break; } else { __label__ = 83; break; } + case 80: + var $361=$wantop; + var $362=(($361) & 1); + if ($362) { __label__ = 81; break; } else { __label__ = 82; break; } + case 81: + var $364=$2; + _parseerror($364, ((STRING_TABLE.__str57629)|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)); + __label__ = 165; break; + case 82: + __label__ = 152; break; + case 83: + $olast=0; + $o=0; + __label__ = 84; break; + case 84: + var $368=$o; + var $369=HEAP32[((_operator_count)>>2)]; + var $370=(($368)>>>0) < (($369)>>>0); + if ($370) { __label__ = 85; break; } else { __label__ = 91; break; } + case 85: + var $372=$o; + var $373=HEAP32[((_operators)>>2)]; + var $374=(($373+($372)*(24))|0); + var $375=(($374+20)|0); + var $376=HEAP32[(($375)>>2)]; + var $377=$376 & 2; + var $378=(($377)|0)!=0; + var $379=$378 ^ 1; + var $380=(($379)&1); + var $381=$wantop; + var $382=(($381) & 1); + var $383=(($382)&1); + var $384=(($380)|0)==(($383)|0); + if ($384) { __label__ = 86; break; } else { __label__ = 89; break; } + case 86: + var $386=$o; + var $387=HEAP32[((_operators)>>2)]; + var $388=(($387+($386)*(24))|0); + var $389=(($388+20)|0); + var $390=HEAP32[(($389)>>2)]; + var $391=$390 & 1; + var $392=(($391)|0)!=0; + if ($392) { __label__ = 89; break; } else { __label__ = 87; break; } + case 87: + var $394=$2; + var $395=(($394)|0); + var $396=HEAP32[(($395)>>2)]; + var $397=(($396+292)|0); + var $398=(($397+4)|0); + var $399=HEAP32[(($398)>>2)]; + var $400=$o; + var $401=HEAP32[((_operators)>>2)]; + var $402=(($401+($400)*(24))|0); + var $403=(($402)|0); + var $404=HEAP32[(($403)>>2)]; + var $405=_strcmp($399, $404); + var $406=(($405)|0)!=0; + if ($406) { __label__ = 89; break; } else { __label__ = 88; break; } + case 88: + __label__ = 91; break; + case 89: + __label__ = 90; break; + case 90: + var $410=$o; + var $411=((($410)+(1))|0); + $o=$411; + __label__ = 84; break; + case 91: + var $413=$o; + var $414=HEAP32[((_operator_count)>>2)]; + var $415=(($413)|0)==(($414)|0); + if ($415) { __label__ = 92; break; } else { __label__ = 93; break; } + case 92: + __label__ = 152; break; + case 93: + var $418=$o; + var $419=HEAP32[((_operators)>>2)]; + var $420=(($419+($418)*(24))|0); + $op=$420; + var $421=$op; + var $422=(($421+8)|0); + var $423=HEAP32[(($422)>>2)]; + var $424=(($423)|0)==44; + if ($424) { __label__ = 94; break; } else { __label__ = 97; break; } + case 94: + var $426=$parens; + var $427=(($426)|0)!=0; + if ($427) { __label__ = 97; break; } else { __label__ = 95; break; } + case 95: + var $429=$3; + var $430=(($429) & 1); + if ($430) { __label__ = 96; break; } else { __label__ = 97; break; } + case 96: + var $432=$2; + var $433=(($432+4)|0); + HEAP32[(($433)>>2)]=44; + __label__ = 152; break; + case 97: + var $435=(($sy+16)|0); + var $436=HEAP32[(($435)>>2)]; + var $437=(($436)|0)!=0; + if ($437) { __label__ = 98; break; } else { __label__ = 100; break; } + case 98: + var $439=(($sy+16)|0); + var $440=HEAP32[(($439)>>2)]; + var $441=((($440)-(1))|0); + var $442=(($sy+12)|0); + var $443=HEAP32[(($442)>>2)]; + var $444=(($443+($441)*(28))|0); + var $445=(($444+4)|0); + var $446=HEAP32[(($445)>>2)]; + var $447=(($446)|0)!=0; + if ($447) { __label__ = 100; break; } else { __label__ = 99; break; } + case 99: + var $449=(($sy+16)|0); + var $450=HEAP32[(($449)>>2)]; + var $451=((($450)-(1))|0); + var $452=(($sy+12)|0); + var $453=HEAP32[(($452)>>2)]; + var $454=(($453+($451)*(28))|0); + var $455=(($454)|0); + var $456=HEAP32[(($455)>>2)]; + var $457=((($456)-(1))|0); + var $458=HEAP32[((_operators)>>2)]; + var $459=(($458+($457)*(24))|0); + $olast=$459; + __label__ = 100; break; + case 100: + __label__ = 101; break; + case 101: + var $462=$olast; + var $463=(($462)|0)!=0; + if ($463) { __label__ = 102; break; } else { var $490 = 0;__label__ = 107; break; } + case 102: + var $465=$op; + var $466=(($465+16)|0); + var $467=HEAP32[(($466)>>2)]; + var $468=$olast; + var $469=(($468+16)|0); + var $470=HEAP32[(($469)>>2)]; + var $471=(($467)>>>0) < (($470)>>>0); + if ($471) { var $488 = 1;__label__ = 106; break; } else { __label__ = 103; break; } + case 103: + var $473=$op; + var $474=(($473+12)|0); + var $475=HEAP32[(($474)>>2)]; + var $476=(($475)|0)==0; + if ($476) { __label__ = 104; break; } else { var $486 = 0;__label__ = 105; break; } + case 104: + var $478=$op; + var $479=(($478+16)|0); + var $480=HEAP32[(($479)>>2)]; + var $481=$olast; + var $482=(($481+16)|0); + var $483=HEAP32[(($482)>>2)]; + var $484=(($480)>>>0) <= (($483)>>>0); + var $486 = $484;__label__ = 105; break; + case 105: + var $486; + var $488 = $486;__label__ = 106; break; + case 106: + var $488; + var $490 = $488;__label__ = 107; break; + case 107: + var $490; + if ($490) { __label__ = 108; break; } else { __label__ = 115; break; } + case 108: + var $492=$2; + var $493=_parser_sy_pop($492, $sy); + if ($493) { __label__ = 110; break; } else { __label__ = 109; break; } + case 109: + __label__ = 165; break; + case 110: + var $496=(($sy+16)|0); + var $497=HEAP32[(($496)>>2)]; + var $498=(($497)|0)!=0; + if ($498) { __label__ = 111; break; } else { __label__ = 113; break; } + case 111: + var $500=(($sy+16)|0); + var $501=HEAP32[(($500)>>2)]; + var $502=((($501)-(1))|0); + var $503=(($sy+12)|0); + var $504=HEAP32[(($503)>>2)]; + var $505=(($504+($502)*(28))|0); + var $506=(($505+4)|0); + var $507=HEAP32[(($506)>>2)]; + var $508=(($507)|0)!=0; + if ($508) { __label__ = 113; break; } else { __label__ = 112; break; } + case 112: + var $510=(($sy+16)|0); + var $511=HEAP32[(($510)>>2)]; + var $512=((($511)-(1))|0); + var $513=(($sy+12)|0); + var $514=HEAP32[(($513)>>2)]; + var $515=(($514+($512)*(28))|0); + var $516=(($515)|0); + var $517=HEAP32[(($516)>>2)]; + var $518=((($517)-(1))|0); + var $519=HEAP32[((_operators)>>2)]; + var $520=(($519+($518)*(24))|0); + $olast=$520; + __label__ = 114; break; + case 113: + $olast=0; + __label__ = 114; break; + case 114: + __label__ = 101; break; + case 115: + var $524=$op; + var $525=(($524+8)|0); + var $526=HEAP32[(($525)>>2)]; + var $527=(($526)|0)==46; + if ($527) { __label__ = 116; break; } else { __label__ = 126; break; } + case 116: + var $529=HEAP32[((_opts_standard)>>2)]; + var $530=(($529)|0)==3; + if ($530) { __label__ = 117; break; } else { __label__ = 126; break; } + case 117: + var $532=(($sy+4)|0); + var $533=HEAP32[(($532)>>2)]; + var $534=((($533)-(1))|0); + var $535=(($sy)|0); + var $536=HEAP32[(($535)>>2)]; + var $537=(($536+($534)*(28))|0); + var $538=(($537+12)|0); + var $539=HEAP32[(($538)>>2)]; + $prevex=$539; + var $540=$prevex; + var $541=(($540)|0)!=0; + if ($541) { __label__ = 119; break; } else { __label__ = 118; break; } + case 118: + var $543=$2; + _parseerror($543, ((STRING_TABLE.__str64636)|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)); + __label__ = 165; break; + case 119: + var $545=$prevex; + var $546=$545; + var $547=(($546+24)|0); + var $548=HEAP32[(($547)>>2)]; + var $549=(($548)|0)==4; + if ($549) { __label__ = 120; break; } else { __label__ = 121; break; } + case 120: + var $551=$2; + var $552=(($551+120)|0); + HEAP32[(($552)>>2)]=4; + __label__ = 125; break; + case 121: + var $554=$prevex; + var $555=$554; + var $556=(($555+24)|0); + var $557=HEAP32[(($556)>>2)]; + var $558=(($557)|0)==3; + if ($558) { __label__ = 122; break; } else { __label__ = 123; break; } + case 122: + var $560=$2; + var $561=(($560+120)|0); + HEAP32[(($561)>>2)]=3; + __label__ = 124; break; + case 123: + var $563=$2; + _parseerror($563, ((STRING_TABLE.__str65637)|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)); + __label__ = 165; break; + case 124: + __label__ = 125; break; + case 125: + $gotmemberof=1; + __label__ = 126; break; + case 126: + var $567=$op; + var $568=(($567+8)|0); + var $569=HEAP32[(($568)>>2)]; + var $570=(($569)|0)==40; + if ($570) { __label__ = 127; break; } else { __label__ = 135; break; } + case 127: + var $572=$wantop; + var $573=(($572) & 1); + if ($573) { __label__ = 128; break; } else { __label__ = 131; break; } + case 128: + var $575=$parens; + var $576=((($575)+(1))|0); + $parens=$576; + var $577=$2; + var $578=(($577)|0); + var $579=HEAP32[(($578)>>2)]; + var $580=(($579+292)|0); + var $581=(($580+28)|0); + var $582=(($sy+4)|0); + var $583=HEAP32[(($582)>>2)]; + var $584=((($583)-(1))|0); + var $585=(($581)|0); + var $586=HEAP32[(($585)>>2)]; + var $587=(($581+4)|0); + var $588=HEAP32[(($587)>>2)]; + _syparen($9, $586, $588, 102, $584); + var $589=_shunt_ops_add($sy, $9); + if ($589) { __label__ = 130; break; } else { __label__ = 129; break; } + case 129: + var $591=$2; + _parseerror($591, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 130: + __label__ = 134; break; + case 131: + var $594=$parens; + var $595=((($594)+(1))|0); + $parens=$595; + var $596=$2; + var $597=(($596)|0); + var $598=HEAP32[(($597)>>2)]; + var $599=(($598+292)|0); + var $600=(($599+28)|0); + var $601=(($600)|0); + var $602=HEAP32[(($601)>>2)]; + var $603=(($600+4)|0); + var $604=HEAP32[(($603)>>2)]; + _syparen($10, $602, $604, 1, 0); + var $605=_shunt_ops_add($sy, $10); + if ($605) { __label__ = 133; break; } else { __label__ = 132; break; } + case 132: + var $607=$2; + _parseerror($607, ((STRING_TABLE.__str61633)|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)); + __label__ = 165; break; + case 133: + __label__ = 134; break; + case 134: + $wantop=0; + __label__ = 138; break; + case 135: + var $611=$2; + var $612=(($611)|0); + var $613=HEAP32[(($612)>>2)]; + var $614=(($613+292)|0); + var $615=(($614+28)|0); + var $616=$op; + var $617=(($615)|0); + var $618=HEAP32[(($617)>>2)]; + var $619=(($615+4)|0); + var $620=HEAP32[(($619)>>2)]; + _syop($11, $618, $620, $616); + var $621=_shunt_ops_add($sy, $11); + if ($621) { __label__ = 137; break; } else { __label__ = 136; break; } + case 136: + __label__ = 165; break; + case 137: + $wantop=0; + __label__ = 138; break; + case 138: + __label__ = 139; break; + case 139: + __label__ = 140; break; + case 140: + __label__ = 141; break; + case 141: + __label__ = 142; break; + case 142: + __label__ = 143; break; + case 143: + __label__ = 144; break; + case 144: + __label__ = 145; break; + case 145: + __label__ = 146; break; + case 146: + var $633=$2; + var $634=_parser_next($633); + if ($634) { __label__ = 148; break; } else { __label__ = 147; break; } + case 147: + __label__ = 165; break; + case 148: + var $637=$2; + var $638=(($637+4)|0); + var $639=HEAP32[(($638)>>2)]; + var $640=(($639)|0)==59; + if ($640) { __label__ = 150; break; } else { __label__ = 149; break; } + case 149: + var $642=$2; + var $643=(($642+4)|0); + var $644=HEAP32[(($643)>>2)]; + var $645=(($644)|0)==93; + if ($645) { __label__ = 150; break; } else { __label__ = 151; break; } + case 150: + __label__ = 152; break; + case 151: + __label__ = 3; break; + case 152: + __label__ = 153; break; + case 153: + var $650=(($sy+16)|0); + var $651=HEAP32[(($650)>>2)]; + var $652=(($651)|0)!=0; + if ($652) { __label__ = 154; break; } else { __label__ = 157; break; } + case 154: + var $654=$2; + var $655=_parser_sy_pop($654, $sy); + if ($655) { __label__ = 156; break; } else { __label__ = 155; break; } + case 155: + __label__ = 165; break; + case 156: + __label__ = 153; break; + case 157: + var $659=$2; + var $660=(($659)|0); + var $661=HEAP32[(($660)>>2)]; + var $662=(($661+328)|0); + var $663=(($662)|0); + HEAP8[($663)]=1; + var $664=(($sy+4)|0); + var $665=HEAP32[(($664)>>2)]; + var $666=(($665)|0)!=0; + if ($666) { __label__ = 159; break; } else { __label__ = 158; break; } + case 158: + var $668=$2; + _parseerror($668, ((STRING_TABLE.__str66638)|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)); + $expr=0; + __label__ = 160; break; + case 159: + var $670=(($sy)|0); + var $671=HEAP32[(($670)>>2)]; + var $672=(($671)|0); + var $673=(($672+12)|0); + var $674=HEAP32[(($673)>>2)]; + $expr=$674; + __label__ = 160; break; + case 160: + var $676=(($sy)|0); + var $677=HEAP32[(($676)>>2)]; + var $678=(($677)|0)!=0; + if ($678) { __label__ = 161; break; } else { __label__ = 162; break; } + case 161: + var $680=(($sy)|0); + var $681=HEAP32[(($680)>>2)]; + var $682=$681; + _util_memory_d($682, 1393, ((STRING_TABLE.__str572)|0)); + __label__ = 162; break; + case 162: + var $684=(($sy)|0); + HEAP32[(($684)>>2)]=0; + var $685=(($sy+4)|0); + HEAP32[(($685)>>2)]=0; + var $686=(($sy+8)|0); + HEAP32[(($686)>>2)]=0; + var $687=(($sy+12)|0); + var $688=HEAP32[(($687)>>2)]; + var $689=(($688)|0)!=0; + if ($689) { __label__ = 163; break; } else { __label__ = 164; break; } + case 163: + var $691=(($sy+12)|0); + var $692=HEAP32[(($691)>>2)]; + var $693=$692; + _util_memory_d($693, 1394, ((STRING_TABLE.__str572)|0)); + __label__ = 164; break; + case 164: + var $695=(($sy+12)|0); + HEAP32[(($695)>>2)]=0; + var $696=(($sy+16)|0); + HEAP32[(($696)>>2)]=0; + var $697=(($sy+20)|0); + HEAP32[(($697)>>2)]=0; + var $698=$expr; + $1=$698; + __label__ = 170; break; + case 165: + var $700=$2; + var $701=(($700)|0); + var $702=HEAP32[(($701)>>2)]; + var $703=(($702+328)|0); + var $704=(($703)|0); + HEAP8[($704)]=1; + var $705=(($sy)|0); + var $706=HEAP32[(($705)>>2)]; + var $707=(($706)|0)!=0; + if ($707) { __label__ = 166; break; } else { __label__ = 167; break; } + case 166: + var $709=(($sy)|0); + var $710=HEAP32[(($709)>>2)]; + var $711=$710; + _util_memory_d($711, 1400, ((STRING_TABLE.__str572)|0)); + __label__ = 167; break; + case 167: + var $713=(($sy)|0); + HEAP32[(($713)>>2)]=0; + var $714=(($sy+4)|0); + HEAP32[(($714)>>2)]=0; + var $715=(($sy+8)|0); + HEAP32[(($715)>>2)]=0; + var $716=(($sy+12)|0); + var $717=HEAP32[(($716)>>2)]; + var $718=(($717)|0)!=0; + if ($718) { __label__ = 168; break; } else { __label__ = 169; break; } + case 168: + var $720=(($sy+12)|0); + var $721=HEAP32[(($720)>>2)]; + var $722=$721; + _util_memory_d($722, 1401, ((STRING_TABLE.__str572)|0)); + __label__ = 169; break; + case 169: + var $724=(($sy+12)|0); + HEAP32[(($724)>>2)]=0; + var $725=(($sy+16)|0); + HEAP32[(($725)>>2)]=0; + var $726=(($sy+20)|0); + HEAP32[(($726)>>2)]=0; + $1=0; + __label__ = 170; break; + case 170: + var $728=$1; + STACKTOP = __stackBase__; + return $728; + default: assert(0, "bad label: " + __label__); + } +} +_parse_expression_leave["X"]=1; + +function _parser_strdup($str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $out; + $2=$str; + var $3=$2; + var $4=(($3)|0)!=0; + if ($4) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $6=$2; + var $7=HEAP8[($6)]; + var $8=(($7 << 24) >> 24)!=0; + if ($8) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $10=_util_memory_a(1, 194, ((STRING_TABLE.__str572)|0)); + $out=$10; + var $11=$out; + HEAP8[($11)]=0; + var $12=$out; + $1=$12; + __label__ = 6; break; + case 5: + var $14=$2; + var $15=_util_strdup($14); + $1=$15; + __label__ = 6; break; + case 6: + var $17=$1; + ; + return $17; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_reclassify_token($parser) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + $1=$parser; + $i=0; + __label__ = 3; break; + case 3: + var $3=$i; + var $4=HEAP32[((_operator_count)>>2)]; + var $5=(($3)>>>0) < (($4)>>>0); + if ($5) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $7=$1; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($9+292)|0); + var $11=(($10+4)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=$i; + var $14=HEAP32[((_operators)>>2)]; + var $15=(($14+($13)*(24))|0); + var $16=(($15)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=_strcmp($12, $17); + var $19=(($18)|0)!=0; + if ($19) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $21=$1; + var $22=(($21+4)|0); + HEAP32[(($22)>>2)]=131; + __label__ = 8; break; + case 6: + __label__ = 7; break; + case 7: + var $25=$i; + var $26=((($25)+(1))|0); + $i=$26; + __label__ = 3; break; + case 8: + ; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_find_var($parser, $name) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $dummy=__stackBase__; + var $v; + $1=$parser; + $2=$name; + var $3=$1; + var $4=$2; + var $5=_parser_find_local($3, $4, 0, $dummy); + $v=$5; + var $6=$v; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $9=$1; + var $10=$2; + var $11=_parser_find_global($9, $10); + $v=$11; + __label__ = 4; break; + case 4: + var $13=$v; + STACKTOP = __stackBase__; + return $13; + default: assert(0, "bad label: " + __label__); + } +} + + +function _syexp($agg_result, $ctx_0, $ctx_1, $v) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $e=(__stackBase__)+(8); + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + $1=$v; + var $4=(($e)|0); + HEAP32[(($4)>>2)]=0; + var $5=(($e+8)|0); + HEAP32[(($5)>>2)]=0; + var $6=$1; + var $7=(($e+12)|0); + HEAP32[(($7)>>2)]=$6; + var $8=(($e+16)|0); + HEAP32[(($8)>>2)]=0; + var $9=(($e+20)|0); + var $10=$9; + var $11=$ctx; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=(($e+4)|0); + HEAP32[(($12)>>2)]=0; + var $13=$agg_result; + var $14=$e; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($13)>>2)]=HEAP32[(($14)>>2)];HEAP32[((($13)+(4))>>2)]=HEAP32[((($14)+(4))>>2)];HEAP32[((($13)+(8))>>2)]=HEAP32[((($14)+(8))>>2)];HEAP32[((($13)+(12))>>2)]=HEAP32[((($14)+(12))>>2)];HEAP32[((($13)+(16))>>2)]=HEAP32[((($14)+(16))>>2)];HEAP32[((($13)+(20))>>2)]=HEAP32[((($14)+(20))>>2)];HEAP32[((($13)+(24))>>2)]=HEAP32[((($14)+(24))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _parser_const_float($parser, $d) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $out; + $2=$parser; + $3=$d; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+48)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+44)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<2))|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16+64)|0); + var $18=$17; + var $19=(tempDoubleI32[0]=HEAP32[(($18)>>2)],tempDoubleI32[1]=HEAP32[((($18)+(4))>>2)],tempDoubleF64[0]); + var $20=$3; + var $21=$19 == $20; + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $23=$i; + var $24=$2; + var $25=(($24+44)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26+($23<<2))|0); + var $28=HEAP32[(($27)>>2)]; + $1=$28; + __label__ = 11; break; + case 6: + __label__ = 7; break; + case 7: + var $31=$i; + var $32=((($31)+(1))|0); + $i=$32; + __label__ = 3; break; + case 8: + var $34=$2; + var $35=(($34)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($36+292)|0); + var $38=(($37+28)|0); + var $39=(($38)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($38+4)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=_ast_value_new($40, $42, ((STRING_TABLE.__str102674)|0), 2); + $out=$43; + var $44=$out; + var $45=(($44+60)|0); + HEAP8[($45)]=1; + var $46=$3; + var $47=$out; + var $48=(($47+64)|0); + var $49=$48; + (tempDoubleF64[0]=$46,HEAP32[(($49)>>2)]=tempDoubleI32[0],HEAP32[((($49)+(4))>>2)]=tempDoubleI32[1]); + var $50=$2; + var $51=$out; + var $52=_parser_t_imm_float_add($50, $51); + if ($52) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $54=$out; + _ast_value_delete($54); + $1=0; + __label__ = 11; break; + case 10: + var $56=$out; + $1=$56; + __label__ = 11; break; + case 11: + var $58=$1; + ; + return $58; + default: assert(0, "bad label: " + __label__); + } +} +_parser_const_float["X"]=1; + +function _parser_const_string($parser, $str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $out; + $2=$parser; + $3=$str; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+60)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+56)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<2))|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16+64)|0); + var $18=$17; + var $19=HEAP32[(($18)>>2)]; + var $20=$3; + var $21=_strcmp($19, $20); + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $24=$i; + var $25=$2; + var $26=(($25+56)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27+($24<<2))|0); + var $29=HEAP32[(($28)>>2)]; + $1=$29; + __label__ = 11; break; + case 6: + __label__ = 7; break; + case 7: + var $32=$i; + var $33=((($32)+(1))|0); + $i=$33; + __label__ = 3; break; + case 8: + var $35=$2; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37+292)|0); + var $39=(($38+28)|0); + var $40=(($39)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=(($39+4)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=_ast_value_new($41, $43, ((STRING_TABLE.__str102674)|0), 1); + $out=$44; + var $45=$out; + var $46=(($45+60)|0); + HEAP8[($46)]=1; + var $47=$3; + var $48=_parser_strdup($47); + var $49=$out; + var $50=(($49+64)|0); + var $51=$50; + HEAP32[(($51)>>2)]=$48; + var $52=$2; + var $53=$out; + var $54=_parser_t_imm_string_add($52, $53); + if ($54) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $56=$out; + _ast_value_delete($56); + $1=0; + __label__ = 11; break; + case 10: + var $58=$out; + $1=$58; + __label__ = 11; break; + case 11: + var $60=$1; + ; + return $60; + default: assert(0, "bad label: " + __label__); + } +} +_parser_const_string["X"]=1; + +function _parser_const_vector($parser, $v_0, $v_1, $v_2) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $v=__stackBase__; + var $i; + var $out; + $2=$parser; + var $3=(($v)|0); + HEAPF32[(($3)>>2)]=$v_0; + var $4=(($v+4)|0); + HEAPF32[(($4)>>2)]=$v_1; + var $5=(($v+8)|0); + HEAPF32[(($5)>>2)]=$v_2; + $i=0; + __label__ = 3; break; + case 3: + var $7=$i; + var $8=$2; + var $9=(($8+72)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)>>>0) < (($10)>>>0); + if ($11) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $13=$i; + var $14=$2; + var $15=(($14+68)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16+($13<<2))|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+64)|0); + var $20=$19; + var $21=$20; + var $22=$v; + var $23=_memcmp($21, $22, 12); + var $24=(($23)|0)!=0; + if ($24) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $26=$i; + var $27=$2; + var $28=(($27+68)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<2))|0); + var $31=HEAP32[(($30)>>2)]; + $1=$31; + __label__ = 11; break; + case 6: + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 3; break; + case 8: + var $37=$2; + var $38=(($37)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=(($39+292)|0); + var $41=(($40+28)|0); + var $42=(($41)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($41+4)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=_ast_value_new($43, $45, ((STRING_TABLE.__str102674)|0), 3); + $out=$46; + var $47=$out; + var $48=(($47+60)|0); + HEAP8[($48)]=1; + var $49=$out; + var $50=(($49+64)|0); + var $51=$50; + var $52=$51; + var $53=$v; + assert(12 % 1 === 0, 'memcpy given ' + 12 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($52)>>2)]=HEAP32[(($53)>>2)];HEAP32[((($52)+(4))>>2)]=HEAP32[((($53)+(4))>>2)];HEAP32[((($52)+(8))>>2)]=HEAP32[((($53)+(8))>>2)]; + var $54=$2; + var $55=$out; + var $56=_parser_t_imm_vector_add($54, $55); + if ($56) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $58=$out; + _ast_value_delete($58); + $1=0; + __label__ = 11; break; + case 10: + var $60=$out; + $1=$60; + __label__ = 11; break; + case 11: + var $62=$1; + STACKTOP = __stackBase__; + return $62; + default: assert(0, "bad label: " + __label__); + } +} +_parser_const_vector["X"]=1; + +function _parser_close_paren($parser, $sy, $functions_only) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + $2=$parser; + $3=$sy; + var $5=(($functions_only)&1); + $4=$5; + var $6=$3; + var $7=(($6+16)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $11=$2; + _parseerror($11, ((STRING_TABLE.__str93665)|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)); + $1=0; + __label__ = 16; break; + case 4: + __label__ = 5; break; + case 5: + var $14=$3; + var $15=(($14+16)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 6; break; } else { __label__ = 15; break; } + case 6: + var $19=$3; + var $20=(($19+16)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21)-(1))|0); + var $23=$3; + var $24=(($23+12)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25+($22)*(28))|0); + var $27=(($26+4)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0)==102; + if ($29) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $31=$2; + var $32=$3; + var $33=_parser_close_call($31, $32); + if ($33) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 16; break; + case 9: + __label__ = 15; break; + case 10: + var $37=$3; + var $38=(($37+16)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + var $41=$3; + var $42=(($41+12)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($43+($40)*(28))|0); + var $45=(($44+4)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=(($46)|0)==1; + if ($47) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $49=$3; + var $50=(($49+16)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=((($51)-(1))|0); + HEAP32[(($50)>>2)]=$52; + var $53=$4; + var $54=(($53) & 1); + var $55=$54 ^ 1; + $1=$55; + __label__ = 16; break; + case 12: + var $57=$2; + var $58=$3; + var $59=_parser_sy_pop($57, $58); + if ($59) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + $1=0; + __label__ = 16; break; + case 14: + __label__ = 5; break; + case 15: + $1=1; + __label__ = 16; break; + case 16: + var $64=$1; + STACKTOP = __stackBase__; + return $64; + default: assert(0, "bad label: " + __label__); + } +} +_parser_close_paren["X"]=1; + +function _parser_sy_pop($parser, $sy) { + var __stackBase__ = STACKTOP; STACKTOP += 4244; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $op; + var $ctx=__stackBase__; + var $out; + var $exprs=(__stackBase__)+(8); + var $blocks=(__stackBase__)+(20); + var $asvalue=(__stackBase__)+(32); + var $i; + var $assignop; + var $generated_op; + var $4=(__stackBase__)+(44); + var $5=(__stackBase__)+(72); + var $6=(__stackBase__)+(84); + var $7=(__stackBase__)+(96); + var $8=(__stackBase__)+(108); + var $field; + var $ty1=(__stackBase__)+(120); + var $ty2=(__stackBase__)+(1144); + var $ty11=(__stackBase__)+(2168); + var $ty22=(__stackBase__)+(3192); + var $9=(__stackBase__)+(4216); + $2=$parser; + $3=$sy; + $out=0; + $generated_op=0; + var $10=$3; + var $11=(($10+16)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $15=$2; + _parseerror($15, ((STRING_TABLE.__str67639)|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)); + $1=0; + __label__ = 254; break; + case 4: + var $17=$3; + var $18=(($17+16)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=((($19)-(1))|0); + var $21=$3; + var $22=(($21+12)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20)*(28))|0); + var $25=(($24+4)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26)|0)!=0; + if ($27) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $29=$2; + _parseerror($29, ((STRING_TABLE.__str68640)|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)); + $1=0; + __label__ = 254; break; + case 6: + var $31=$3; + var $32=(($31+16)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=((($33)-(1))|0); + var $35=$3; + var $36=(($35+12)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37+($34)*(28))|0); + var $39=(($38)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=((($40)-(1))|0); + var $42=HEAP32[((_operators)>>2)]; + var $43=(($42+($41)*(24))|0); + $op=$43; + var $44=$3; + var $45=(($44+16)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=((($46)-(1))|0); + var $48=$3; + var $49=(($48+12)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=(($50+($47)*(28))|0); + var $52=(($51+20)|0); + var $53=$ctx; + var $54=$52; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($53)>>2)]=HEAP32[(($54)>>2)];HEAP32[((($53)+(4))>>2)]=HEAP32[((($54)+(4))>>2)]; + var $55=$3; + var $56=(($55+4)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$op; + var $59=(($58+4)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($57)>>>0) < (($60)>>>0); + if ($61) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $63=$2; + var $64=$3; + var $65=(($64+4)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=$op; + var $68=(($67)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=$op; + var $71=(($70+8)|0); + var $72=HEAP32[(($71)>>2)]; + _parseerror($63, ((STRING_TABLE.__str69641)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$66,HEAP32[(((tempInt)+(4))>>2)]=$69,HEAP32[(((tempInt)+(8))>>2)]=$72,tempInt)); + $1=0; + __label__ = 254; break; + case 8: + var $74=$3; + var $75=(($74+16)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=((($76)-(1))|0); + HEAP32[(($75)>>2)]=$77; + var $78=$op; + var $79=(($78+4)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=$3; + var $82=(($81+4)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=((($83)-($80))|0); + HEAP32[(($82)>>2)]=$84; + $i=0; + __label__ = 9; break; + case 9: + var $86=$i; + var $87=$op; + var $88=(($87+4)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($86)>>>0) < (($89)>>>0); + if ($90) { __label__ = 10; break; } else { __label__ = 12; break; } + case 10: + var $92=$3; + var $93=(($92+4)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=$i; + var $96=((($94)+($95))|0); + var $97=$3; + var $98=(($97)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=(($99+($96)*(28))|0); + var $101=(($100+12)|0); + var $102=HEAP32[(($101)>>2)]; + var $103=$i; + var $104=(($exprs+($103<<2))|0); + HEAP32[(($104)>>2)]=$102; + var $105=$3; + var $106=(($105+4)|0); + var $107=HEAP32[(($106)>>2)]; + var $108=$i; + var $109=((($107)+($108))|0); + var $110=$3; + var $111=(($110)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($112+($109)*(28))|0); + var $114=(($113+16)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=$i; + var $117=(($blocks+($116<<2))|0); + HEAP32[(($117)>>2)]=$115; + var $118=$i; + var $119=(($exprs+($118<<2))|0); + var $120=HEAP32[(($119)>>2)]; + var $121=$120; + var $122=$i; + var $123=(($asvalue+($122<<2))|0); + HEAP32[(($123)>>2)]=$121; + __label__ = 11; break; + case 11: + var $125=$i; + var $126=((($125)+(1))|0); + $i=$126; + __label__ = 9; break; + case 12: + var $128=(($blocks)|0); + var $129=HEAP32[(($128)>>2)]; + var $130=(($129)|0)!=0; + if ($130) { __label__ = 13; break; } else { __label__ = 16; break; } + case 13: + var $132=(($blocks)|0); + var $133=HEAP32[(($132)>>2)]; + var $134=(($133+72)|0); + var $135=HEAP32[(($134)>>2)]; + var $136=(($135)|0)!=0; + if ($136) { __label__ = 16; break; } else { __label__ = 14; break; } + case 14: + var $138=$op; + var $139=(($138+8)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=(($140)|0)!=44; + if ($141) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $143=$2; + _parseerror($143, ((STRING_TABLE.__str70642)|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)); + $1=0; + __label__ = 254; break; + case 16: + var $145=$op; + var $146=(($145+8)|0); + var $147=HEAP32[(($146)>>2)]; + if ((($147)|0) == 46) { + __label__ = 18; break; + } + else if ((($147)|0) == 44) { + __label__ = 26; break; + } + else if ((($147)|0) == 11600) { + __label__ = 37; break; + } + else if ((($147)|0) == 8528) { + __label__ = 50; break; + } + else if ((($147)|0) == 43) { + __label__ = 75; break; + } + else if ((($147)|0) == 45) { + __label__ = 96; break; + } + else if ((($147)|0) == 42) { + __label__ = 117; break; + } + else if ((($147)|0) == 47) { + __label__ = 158; break; + } + else if ((($147)|0) == 37 || (($147)|0) == 9533) { + __label__ = 168; break; + } + else if ((($147)|0) == 124 || (($147)|0) == 38) { + __label__ = 169; break; + } + else if ((($147)|0) == 94) { + __label__ = 182; break; + } + else if ((($147)|0) == 15420 || (($147)|0) == 15934 || (($147)|0) == 3947581 || (($147)|0) == 4079165) { + __label__ = 183; break; + } + else if ((($147)|0) == 31868) { + __label__ = 184; break; + } + else if ((($147)|0) == 9766) { + __label__ = 185; break; + } + else if ((($147)|0) == 62) { + __label__ = 204; break; + } + else if ((($147)|0) == 60) { + __label__ = 205; break; + } + else if ((($147)|0) == 15933) { + __label__ = 206; break; + } + else if ((($147)|0) == 15421) { + __label__ = 207; break; + } + else if ((($147)|0) == 8509) { + __label__ = 211; break; + } + else if ((($147)|0) == 15677) { + __label__ = 214; break; + } + else if ((($147)|0) == 61) { + __label__ = 217; break; + } + else if ((($147)|0) == 11069 || (($147)|0) == 11581) { + __label__ = 239; break; + } + else { + __label__ = 17; break; + } + + case 17: + var $149=$2; + var $150=$op; + var $151=(($150)|0); + var $152=HEAP32[(($151)>>2)]; + var $153=$op; + var $154=(($153+8)|0); + var $155=HEAP32[(($154)>>2)]; + _parseerror($149, ((STRING_TABLE.__str71643)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$152,HEAP32[(((tempInt)+(4))>>2)]=$155,tempInt)); + $1=0; + __label__ = 254; break; + case 18: + var $157=(($exprs)|0); + var $158=HEAP32[(($157)>>2)]; + var $159=$158; + var $160=(($159+24)|0); + var $161=HEAP32[(($160)>>2)]; + var $162=(($161)|0)==4; + if ($162) { __label__ = 19; break; } else { __label__ = 22; break; } + case 19: + var $164=(($exprs+4)|0); + var $165=HEAP32[(($164)>>2)]; + var $166=$165; + var $167=(($166+24)|0); + var $168=HEAP32[(($167)>>2)]; + var $169=(($168)|0)!=5; + if ($169) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + var $171=$2; + _parseerror($171, ((STRING_TABLE.__str72644)|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)); + $1=0; + __label__ = 254; break; + case 21: + var $173=(($exprs)|0); + var $174=HEAP32[(($173)>>2)]; + var $175=(($exprs+4)|0); + var $176=HEAP32[(($175)>>2)]; + var $177=(($ctx)|0); + var $178=HEAP32[(($177)>>2)]; + var $179=(($ctx+4)|0); + var $180=HEAP32[(($179)>>2)]; + var $181=_ast_entfield_new($178, $180, $174, $176); + var $182=$181; + $out=$182; + __label__ = 25; break; + case 22: + var $184=(($exprs)|0); + var $185=HEAP32[(($184)>>2)]; + var $186=$185; + var $187=(($186+24)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=(($188)|0)==3; + if ($189) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + var $191=$2; + _parseerror($191, ((STRING_TABLE.__str73645)|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)); + $1=0; + __label__ = 254; break; + case 24: + var $193=$2; + _parseerror($193, ((STRING_TABLE.__str74646)|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)); + $1=0; + __label__ = 254; break; + case 25: + __label__ = 251; break; + case 26: + var $196=(($blocks)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=(($197)|0)!=0; + if ($198) { __label__ = 27; break; } else { __label__ = 30; break; } + case 27: + var $200=(($blocks)|0); + var $201=HEAP32[(($200)>>2)]; + var $202=(($exprs+4)|0); + var $203=HEAP32[(($202)>>2)]; + var $204=_ast_block_exprs_add($201, $203); + if ($204) { __label__ = 29; break; } else { __label__ = 28; break; } + case 28: + $1=0; + __label__ = 254; break; + case 29: + __label__ = 34; break; + case 30: + var $208=(($ctx)|0); + var $209=HEAP32[(($208)>>2)]; + var $210=(($ctx+4)|0); + var $211=HEAP32[(($210)>>2)]; + var $212=_ast_block_new($209, $211); + var $213=(($blocks)|0); + HEAP32[(($213)>>2)]=$212; + var $214=(($blocks)|0); + var $215=HEAP32[(($214)>>2)]; + var $216=(($exprs)|0); + var $217=HEAP32[(($216)>>2)]; + var $218=_ast_block_exprs_add($215, $217); + if ($218) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + var $220=(($blocks)|0); + var $221=HEAP32[(($220)>>2)]; + var $222=(($exprs+4)|0); + var $223=HEAP32[(($222)>>2)]; + var $224=_ast_block_exprs_add($221, $223); + if ($224) { __label__ = 33; break; } else { __label__ = 32; break; } + case 32: + $1=0; + __label__ = 254; break; + case 33: + __label__ = 34; break; + case 34: + var $228=(($blocks)|0); + var $229=HEAP32[(($228)>>2)]; + var $230=(($exprs+4)|0); + var $231=HEAP32[(($230)>>2)]; + var $232=_ast_block_set_type($229, $231); + if ($232) { __label__ = 36; break; } else { __label__ = 35; break; } + case 35: + $1=0; + __label__ = 254; break; + case 36: + var $235=$3; + var $236=(($235+4)|0); + var $237=HEAP32[(($236)>>2)]; + var $238=((($237)+(1))|0); + HEAP32[(($236)>>2)]=$238; + var $239=$3; + var $240=(($239)|0); + var $241=HEAP32[(($240)>>2)]; + var $242=(($241+($237)*(28))|0); + var $243=(($blocks)|0); + var $244=HEAP32[(($243)>>2)]; + var $245=(($ctx)|0); + var $246=HEAP32[(($245)>>2)]; + var $247=(($ctx+4)|0); + var $248=HEAP32[(($247)>>2)]; + _syblock($4, $246, $248, $244); + var $249=$242; + var $250=$4; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($249)>>2)]=HEAP32[(($250)>>2)];HEAP32[((($249)+(4))>>2)]=HEAP32[((($250)+(4))>>2)];HEAP32[((($249)+(8))>>2)]=HEAP32[((($250)+(8))>>2)];HEAP32[((($249)+(12))>>2)]=HEAP32[((($250)+(12))>>2)];HEAP32[((($249)+(16))>>2)]=HEAP32[((($250)+(16))>>2)];HEAP32[((($249)+(20))>>2)]=HEAP32[((($250)+(20))>>2)];HEAP32[((($249)+(24))>>2)]=HEAP32[((($250)+(24))>>2)]; + $1=1; + __label__ = 254; break; + case 37: + var $252=(($exprs)|0); + var $253=HEAP32[(($252)>>2)]; + var $254=$253; + var $255=(($254+24)|0); + var $256=HEAP32[(($255)>>2)]; + if ((($256)|0) == 2) { + __label__ = 38; break; + } + else if ((($256)|0) == 3) { + __label__ = 43; break; + } + else { + __label__ = 48; break; + } + + case 38: + var $258=(($exprs)|0); + var $259=HEAP32[(($258)>>2)]; + var $260=$259; + var $261=(($260+12)|0); + var $262=HEAP32[(($261)>>2)]; + var $263=(($262)|0)==2; + if ($263) { __label__ = 39; break; } else { __label__ = 41; break; } + case 39: + var $265=(($exprs)|0); + var $266=HEAP32[(($265)>>2)]; + var $267=$266; + var $268=(($267+60)|0); + var $269=HEAP8[($268)]; + var $270=(($269) & 1); + if ($270) { __label__ = 40; break; } else { __label__ = 41; break; } + case 40: + var $272=$2; + var $273=(($asvalue)|0); + var $274=HEAP32[(($273)>>2)]; + var $275=(($274+64)|0); + var $276=$275; + var $277=(tempDoubleI32[0]=HEAP32[(($276)>>2)],tempDoubleI32[1]=HEAP32[((($276)+(4))>>2)],tempDoubleF64[0]); + var $278=(-$277); + var $279=_parser_const_float($272, $278); + var $280=$279; + $out=$280; + __label__ = 42; break; + case 41: + var $282=$2; + var $283=_parser_const_float_0($282); + var $284=$283; + var $285=(($exprs)|0); + var $286=HEAP32[(($285)>>2)]; + var $287=(($ctx)|0); + var $288=HEAP32[(($287)>>2)]; + var $289=(($ctx+4)|0); + var $290=HEAP32[(($289)>>2)]; + var $291=_ast_binary_new($288, $290, 8, $284, $286); + var $292=$291; + $out=$292; + __label__ = 42; break; + case 42: + __label__ = 49; break; + case 43: + var $295=(($exprs)|0); + var $296=HEAP32[(($295)>>2)]; + var $297=$296; + var $298=(($297+12)|0); + var $299=HEAP32[(($298)>>2)]; + var $300=(($299)|0)==2; + if ($300) { __label__ = 44; break; } else { __label__ = 46; break; } + case 44: + var $302=(($exprs)|0); + var $303=HEAP32[(($302)>>2)]; + var $304=$303; + var $305=(($304+60)|0); + var $306=HEAP8[($305)]; + var $307=(($306) & 1); + if ($307) { __label__ = 45; break; } else { __label__ = 46; break; } + case 45: + var $309=$2; + var $310=(($asvalue)|0); + var $311=HEAP32[(($310)>>2)]; + var $312=(($311+64)|0); + var $313=$312; + var $314=(($313)|0); + var $315=HEAPF32[(($314)>>2)]; + var $316=(-$315); + var $317=(($asvalue)|0); + var $318=HEAP32[(($317)>>2)]; + var $319=(($318+64)|0); + var $320=$319; + var $321=(($320+4)|0); + var $322=HEAPF32[(($321)>>2)]; + var $323=(-$322); + var $324=(($asvalue)|0); + var $325=HEAP32[(($324)>>2)]; + var $326=(($325+64)|0); + var $327=$326; + var $328=(($327+8)|0); + var $329=HEAPF32[(($328)>>2)]; + var $330=(-$329); + var $331=_parser_const_vector_f($309, $316, $323, $330); + var $332=$331; + $out=$332; + __label__ = 47; break; + case 46: + var $334=$2; + var $335=_parser_const_vector_0($334); + var $336=$335; + var $337=(($exprs)|0); + var $338=HEAP32[(($337)>>2)]; + var $339=(($ctx)|0); + var $340=HEAP32[(($339)>>2)]; + var $341=(($ctx+4)|0); + var $342=HEAP32[(($341)>>2)]; + var $343=_ast_binary_new($340, $342, 9, $336, $338); + var $344=$343; + $out=$344; + __label__ = 47; break; + case 47: + __label__ = 49; break; + case 48: + var $347=$2; + var $348=(($exprs)|0); + var $349=HEAP32[(($348)>>2)]; + var $350=$349; + var $351=(($350+24)|0); + var $352=HEAP32[(($351)>>2)]; + var $353=((_type_name+($352<<2))|0); + var $354=HEAP32[(($353)>>2)]; + _parseerror($347, ((STRING_TABLE.__str75647)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$354,tempInt)); + $1=0; + __label__ = 254; break; + case 49: + __label__ = 251; break; + case 50: + var $357=(($exprs)|0); + var $358=HEAP32[(($357)>>2)]; + var $359=$358; + var $360=(($359+24)|0); + var $361=HEAP32[(($360)>>2)]; + if ((($361)|0) == 2) { + __label__ = 51; break; + } + else if ((($361)|0) == 3) { + __label__ = 56; break; + } + else if ((($361)|0) == 1) { + __label__ = 64; break; + } + else if ((($361)|0) == 4) { + __label__ = 71; break; + } + else if ((($361)|0) == 6) { + __label__ = 72; break; + } + else { + __label__ = 73; break; + } + + case 51: + var $363=(($exprs)|0); + var $364=HEAP32[(($363)>>2)]; + var $365=$364; + var $366=(($365+12)|0); + var $367=HEAP32[(($366)>>2)]; + var $368=(($367)|0)==2; + if ($368) { __label__ = 52; break; } else { __label__ = 54; break; } + case 52: + var $370=(($exprs)|0); + var $371=HEAP32[(($370)>>2)]; + var $372=$371; + var $373=(($372+60)|0); + var $374=HEAP8[($373)]; + var $375=(($374) & 1); + if ($375) { __label__ = 53; break; } else { __label__ = 54; break; } + case 53: + var $377=$2; + var $378=(($asvalue)|0); + var $379=HEAP32[(($378)>>2)]; + var $380=(($379+64)|0); + var $381=$380; + var $382=(tempDoubleI32[0]=HEAP32[(($381)>>2)],tempDoubleI32[1]=HEAP32[((($381)+(4))>>2)],tempDoubleF64[0]); + var $383=$382 != 0; + var $384=$383 ^ 1; + var $385=(($384)&1); + var $386=(($385)|0); + var $387=_parser_const_float($377, $386); + var $388=$387; + $out=$388; + __label__ = 55; break; + case 54: + var $390=(($exprs)|0); + var $391=HEAP32[(($390)>>2)]; + var $392=(($ctx)|0); + var $393=HEAP32[(($392)>>2)]; + var $394=(($ctx+4)|0); + var $395=HEAP32[(($394)>>2)]; + var $396=_ast_unary_new($393, $395, 44, $391); + var $397=$396; + $out=$397; + __label__ = 55; break; + case 55: + __label__ = 74; break; + case 56: + var $400=(($exprs)|0); + var $401=HEAP32[(($400)>>2)]; + var $402=$401; + var $403=(($402+12)|0); + var $404=HEAP32[(($403)>>2)]; + var $405=(($404)|0)==2; + if ($405) { __label__ = 57; break; } else { __label__ = 62; break; } + case 57: + var $407=(($exprs)|0); + var $408=HEAP32[(($407)>>2)]; + var $409=$408; + var $410=(($409+60)|0); + var $411=HEAP8[($410)]; + var $412=(($411) & 1); + if ($412) { __label__ = 58; break; } else { __label__ = 62; break; } + case 58: + var $414=$2; + var $415=(($asvalue)|0); + var $416=HEAP32[(($415)>>2)]; + var $417=(($416+64)|0); + var $418=$417; + var $419=(($418)|0); + var $420=HEAPF32[(($419)>>2)]; + var $421=$420 != 0; + if ($421) { var $440 = 0;__label__ = 61; break; } else { __label__ = 59; break; } + case 59: + var $423=(($asvalue)|0); + var $424=HEAP32[(($423)>>2)]; + var $425=(($424+64)|0); + var $426=$425; + var $427=(($426+4)|0); + var $428=HEAPF32[(($427)>>2)]; + var $429=$428 != 0; + if ($429) { var $440 = 0;__label__ = 61; break; } else { __label__ = 60; break; } + case 60: + var $431=(($asvalue)|0); + var $432=HEAP32[(($431)>>2)]; + var $433=(($432+64)|0); + var $434=$433; + var $435=(($434+8)|0); + var $436=HEAPF32[(($435)>>2)]; + var $437=$436 != 0; + var $438=$437 ^ 1; + var $440 = $438;__label__ = 61; break; + case 61: + var $440; + var $441=(($440)&1); + var $442=(($441)|0); + var $443=_parser_const_float($414, $442); + var $444=$443; + $out=$444; + __label__ = 63; break; + case 62: + var $446=(($exprs)|0); + var $447=HEAP32[(($446)>>2)]; + var $448=(($ctx)|0); + var $449=HEAP32[(($448)>>2)]; + var $450=(($ctx+4)|0); + var $451=HEAP32[(($450)>>2)]; + var $452=_ast_unary_new($449, $451, 45, $447); + var $453=$452; + $out=$453; + __label__ = 63; break; + case 63: + __label__ = 74; break; + case 64: + var $456=(($exprs)|0); + var $457=HEAP32[(($456)>>2)]; + var $458=$457; + var $459=(($458+12)|0); + var $460=HEAP32[(($459)>>2)]; + var $461=(($460)|0)==2; + if ($461) { __label__ = 65; break; } else { __label__ = 69; break; } + case 65: + var $463=(($exprs)|0); + var $464=HEAP32[(($463)>>2)]; + var $465=$464; + var $466=(($465+60)|0); + var $467=HEAP8[($466)]; + var $468=(($467) & 1); + if ($468) { __label__ = 66; break; } else { __label__ = 69; break; } + case 66: + var $470=$2; + var $471=(($asvalue)|0); + var $472=HEAP32[(($471)>>2)]; + var $473=(($472+64)|0); + var $474=$473; + var $475=HEAP32[(($474)>>2)]; + var $476=(($475)|0)!=0; + if ($476) { __label__ = 67; break; } else { var $487 = 1;__label__ = 68; break; } + case 67: + var $478=(($asvalue)|0); + var $479=HEAP32[(($478)>>2)]; + var $480=(($479+64)|0); + var $481=$480; + var $482=HEAP32[(($481)>>2)]; + var $483=HEAP8[($482)]; + var $484=(($483 << 24) >> 24)!=0; + var $485=$484 ^ 1; + var $487 = $485;__label__ = 68; break; + case 68: + var $487; + var $488=(($487)&1); + var $489=(($488)|0); + var $490=_parser_const_float($470, $489); + var $491=$490; + $out=$491; + __label__ = 70; break; + case 69: + var $493=(($exprs)|0); + var $494=HEAP32[(($493)>>2)]; + var $495=(($ctx)|0); + var $496=HEAP32[(($495)>>2)]; + var $497=(($ctx+4)|0); + var $498=HEAP32[(($497)>>2)]; + var $499=_ast_unary_new($496, $498, 46, $494); + var $500=$499; + $out=$500; + __label__ = 70; break; + case 70: + __label__ = 74; break; + case 71: + var $503=(($exprs)|0); + var $504=HEAP32[(($503)>>2)]; + var $505=(($ctx)|0); + var $506=HEAP32[(($505)>>2)]; + var $507=(($ctx+4)|0); + var $508=HEAP32[(($507)>>2)]; + var $509=_ast_unary_new($506, $508, 47, $504); + var $510=$509; + $out=$510; + __label__ = 74; break; + case 72: + var $512=(($exprs)|0); + var $513=HEAP32[(($512)>>2)]; + var $514=(($ctx)|0); + var $515=HEAP32[(($514)>>2)]; + var $516=(($ctx+4)|0); + var $517=HEAP32[(($516)>>2)]; + var $518=_ast_unary_new($515, $517, 48, $513); + var $519=$518; + $out=$519; + __label__ = 74; break; + case 73: + var $521=$2; + var $522=(($exprs)|0); + var $523=HEAP32[(($522)>>2)]; + var $524=$523; + var $525=(($524+24)|0); + var $526=HEAP32[(($525)>>2)]; + var $527=((_type_name+($526<<2))|0); + var $528=HEAP32[(($527)>>2)]; + _parseerror($521, ((STRING_TABLE.__str76648)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$528,tempInt)); + $1=0; + __label__ = 254; break; + case 74: + __label__ = 251; break; + case 75: + var $531=(($exprs)|0); + var $532=HEAP32[(($531)>>2)]; + var $533=$532; + var $534=(($533+24)|0); + var $535=HEAP32[(($534)>>2)]; + var $536=(($exprs+4)|0); + var $537=HEAP32[(($536)>>2)]; + var $538=$537; + var $539=(($538+24)|0); + var $540=HEAP32[(($539)>>2)]; + var $541=(($535)|0)!=(($540)|0); + if ($541) { __label__ = 78; break; } else { __label__ = 76; break; } + case 76: + var $543=(($exprs)|0); + var $544=HEAP32[(($543)>>2)]; + var $545=$544; + var $546=(($545+24)|0); + var $547=HEAP32[(($546)>>2)]; + var $548=(($547)|0)!=3; + if ($548) { __label__ = 77; break; } else { __label__ = 79; break; } + case 77: + var $550=(($exprs)|0); + var $551=HEAP32[(($550)>>2)]; + var $552=$551; + var $553=(($552+24)|0); + var $554=HEAP32[(($553)>>2)]; + var $555=(($554)|0)!=2; + if ($555) { __label__ = 78; break; } else { __label__ = 79; break; } + case 78: + var $557=$2; + var $558=(($exprs)|0); + var $559=HEAP32[(($558)>>2)]; + var $560=$559; + var $561=(($560+24)|0); + var $562=HEAP32[(($561)>>2)]; + var $563=((_type_name+($562<<2))|0); + var $564=HEAP32[(($563)>>2)]; + var $565=(($exprs+4)|0); + var $566=HEAP32[(($565)>>2)]; + var $567=$566; + var $568=(($567+24)|0); + var $569=HEAP32[(($568)>>2)]; + var $570=((_type_name+($569<<2))|0); + var $571=HEAP32[(($570)>>2)]; + _parseerror($557, ((STRING_TABLE.__str77649)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$564,HEAP32[(((tempInt)+(4))>>2)]=$571,tempInt)); + $1=0; + __label__ = 254; break; + case 79: + var $573=(($exprs)|0); + var $574=HEAP32[(($573)>>2)]; + var $575=$574; + var $576=(($575+24)|0); + var $577=HEAP32[(($576)>>2)]; + if ((($577)|0) == 2) { + __label__ = 80; break; + } + else if ((($577)|0) == 3) { + __label__ = 87; break; + } + else { + __label__ = 94; break; + } + + case 80: + var $579=(($exprs)|0); + var $580=HEAP32[(($579)>>2)]; + var $581=$580; + var $582=(($581+12)|0); + var $583=HEAP32[(($582)>>2)]; + var $584=(($583)|0)==2; + if ($584) { __label__ = 81; break; } else { __label__ = 85; break; } + case 81: + var $586=(($exprs)|0); + var $587=HEAP32[(($586)>>2)]; + var $588=$587; + var $589=(($588+60)|0); + var $590=HEAP8[($589)]; + var $591=(($590) & 1); + if ($591) { __label__ = 82; break; } else { __label__ = 85; break; } + case 82: + var $593=(($exprs+4)|0); + var $594=HEAP32[(($593)>>2)]; + var $595=$594; + var $596=(($595+12)|0); + var $597=HEAP32[(($596)>>2)]; + var $598=(($597)|0)==2; + if ($598) { __label__ = 83; break; } else { __label__ = 85; break; } + case 83: + var $600=(($exprs+4)|0); + var $601=HEAP32[(($600)>>2)]; + var $602=$601; + var $603=(($602+60)|0); + var $604=HEAP8[($603)]; + var $605=(($604) & 1); + if ($605) { __label__ = 84; break; } else { __label__ = 85; break; } + case 84: + var $607=$2; + var $608=(($asvalue)|0); + var $609=HEAP32[(($608)>>2)]; + var $610=(($609+64)|0); + var $611=$610; + var $612=(tempDoubleI32[0]=HEAP32[(($611)>>2)],tempDoubleI32[1]=HEAP32[((($611)+(4))>>2)],tempDoubleF64[0]); + var $613=(($asvalue+4)|0); + var $614=HEAP32[(($613)>>2)]; + var $615=(($614+64)|0); + var $616=$615; + var $617=(tempDoubleI32[0]=HEAP32[(($616)>>2)],tempDoubleI32[1]=HEAP32[((($616)+(4))>>2)],tempDoubleF64[0]); + var $618=($612)+($617); + var $619=_parser_const_float($607, $618); + var $620=$619; + $out=$620; + __label__ = 86; break; + case 85: + var $622=(($exprs)|0); + var $623=HEAP32[(($622)>>2)]; + var $624=(($exprs+4)|0); + var $625=HEAP32[(($624)>>2)]; + var $626=(($ctx)|0); + var $627=HEAP32[(($626)>>2)]; + var $628=(($ctx+4)|0); + var $629=HEAP32[(($628)>>2)]; + var $630=_ast_binary_new($627, $629, 6, $623, $625); + var $631=$630; + $out=$631; + __label__ = 86; break; + case 86: + __label__ = 95; break; + case 87: + var $634=(($exprs)|0); + var $635=HEAP32[(($634)>>2)]; + var $636=$635; + var $637=(($636+12)|0); + var $638=HEAP32[(($637)>>2)]; + var $639=(($638)|0)==2; + if ($639) { __label__ = 88; break; } else { __label__ = 92; break; } + case 88: + var $641=(($exprs)|0); + var $642=HEAP32[(($641)>>2)]; + var $643=$642; + var $644=(($643+60)|0); + var $645=HEAP8[($644)]; + var $646=(($645) & 1); + if ($646) { __label__ = 89; break; } else { __label__ = 92; break; } + case 89: + var $648=(($exprs+4)|0); + var $649=HEAP32[(($648)>>2)]; + var $650=$649; + var $651=(($650+12)|0); + var $652=HEAP32[(($651)>>2)]; + var $653=(($652)|0)==2; + if ($653) { __label__ = 90; break; } else { __label__ = 92; break; } + case 90: + var $655=(($exprs+4)|0); + var $656=HEAP32[(($655)>>2)]; + var $657=$656; + var $658=(($657+60)|0); + var $659=HEAP8[($658)]; + var $660=(($659) & 1); + if ($660) { __label__ = 91; break; } else { __label__ = 92; break; } + case 91: + var $662=$2; + var $663=(($asvalue)|0); + var $664=HEAP32[(($663)>>2)]; + var $665=(($664+64)|0); + var $666=$665; + var $667=(($asvalue+4)|0); + var $668=HEAP32[(($667)>>2)]; + var $669=(($668+64)|0); + var $670=$669; + var $671=(($666)|0); + var $672=HEAPF32[(($671)>>2)]; + var $673=(($666+4)|0); + var $674=HEAPF32[(($673)>>2)]; + var $675=(($666+8)|0); + var $676=HEAPF32[(($675)>>2)]; + var $677=(($670)|0); + var $678=HEAPF32[(($677)>>2)]; + var $679=(($670+4)|0); + var $680=HEAPF32[(($679)>>2)]; + var $681=(($670+8)|0); + var $682=HEAPF32[(($681)>>2)]; + _vec3_add($5, $672, $674, $676, $678, $680, $682); + var $683=(($5)|0); + var $684=HEAPF32[(($683)>>2)]; + var $685=(($5+4)|0); + var $686=HEAPF32[(($685)>>2)]; + var $687=(($5+8)|0); + var $688=HEAPF32[(($687)>>2)]; + var $689=_parser_const_vector($662, $684, $686, $688); + var $690=$689; + $out=$690; + __label__ = 93; break; + case 92: + var $692=(($exprs)|0); + var $693=HEAP32[(($692)>>2)]; + var $694=(($exprs+4)|0); + var $695=HEAP32[(($694)>>2)]; + var $696=(($ctx)|0); + var $697=HEAP32[(($696)>>2)]; + var $698=(($ctx+4)|0); + var $699=HEAP32[(($698)>>2)]; + var $700=_ast_binary_new($697, $699, 7, $693, $695); + var $701=$700; + $out=$701; + __label__ = 93; break; + case 93: + __label__ = 95; break; + case 94: + var $704=$2; + var $705=(($exprs)|0); + var $706=HEAP32[(($705)>>2)]; + var $707=$706; + var $708=(($707+24)|0); + var $709=HEAP32[(($708)>>2)]; + var $710=((_type_name+($709<<2))|0); + var $711=HEAP32[(($710)>>2)]; + var $712=(($exprs+4)|0); + var $713=HEAP32[(($712)>>2)]; + var $714=$713; + var $715=(($714+24)|0); + var $716=HEAP32[(($715)>>2)]; + var $717=((_type_name+($716<<2))|0); + var $718=HEAP32[(($717)>>2)]; + _parseerror($704, ((STRING_TABLE.__str77649)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$711,HEAP32[(((tempInt)+(4))>>2)]=$718,tempInt)); + $1=0; + __label__ = 254; break; + case 95: + __label__ = 251; break; + case 96: + var $721=(($exprs)|0); + var $722=HEAP32[(($721)>>2)]; + var $723=$722; + var $724=(($723+24)|0); + var $725=HEAP32[(($724)>>2)]; + var $726=(($exprs+4)|0); + var $727=HEAP32[(($726)>>2)]; + var $728=$727; + var $729=(($728+24)|0); + var $730=HEAP32[(($729)>>2)]; + var $731=(($725)|0)!=(($730)|0); + if ($731) { __label__ = 99; break; } else { __label__ = 97; break; } + case 97: + var $733=(($exprs)|0); + var $734=HEAP32[(($733)>>2)]; + var $735=$734; + var $736=(($735+24)|0); + var $737=HEAP32[(($736)>>2)]; + var $738=(($737)|0)!=3; + if ($738) { __label__ = 98; break; } else { __label__ = 100; break; } + case 98: + var $740=(($exprs)|0); + var $741=HEAP32[(($740)>>2)]; + var $742=$741; + var $743=(($742+24)|0); + var $744=HEAP32[(($743)>>2)]; + var $745=(($744)|0)!=2; + if ($745) { __label__ = 99; break; } else { __label__ = 100; break; } + case 99: + var $747=$2; + var $748=(($exprs+4)|0); + var $749=HEAP32[(($748)>>2)]; + var $750=$749; + var $751=(($750+24)|0); + var $752=HEAP32[(($751)>>2)]; + var $753=((_type_name+($752<<2))|0); + var $754=HEAP32[(($753)>>2)]; + var $755=(($exprs)|0); + var $756=HEAP32[(($755)>>2)]; + var $757=$756; + var $758=(($757+24)|0); + var $759=HEAP32[(($758)>>2)]; + var $760=((_type_name+($759<<2))|0); + var $761=HEAP32[(($760)>>2)]; + _parseerror($747, ((STRING_TABLE.__str78650)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$754,HEAP32[(((tempInt)+(4))>>2)]=$761,tempInt)); + $1=0; + __label__ = 254; break; + case 100: + var $763=(($exprs)|0); + var $764=HEAP32[(($763)>>2)]; + var $765=$764; + var $766=(($765+24)|0); + var $767=HEAP32[(($766)>>2)]; + if ((($767)|0) == 2) { + __label__ = 101; break; + } + else if ((($767)|0) == 3) { + __label__ = 108; break; + } + else { + __label__ = 115; break; + } + + case 101: + var $769=(($exprs)|0); + var $770=HEAP32[(($769)>>2)]; + var $771=$770; + var $772=(($771+12)|0); + var $773=HEAP32[(($772)>>2)]; + var $774=(($773)|0)==2; + if ($774) { __label__ = 102; break; } else { __label__ = 106; break; } + case 102: + var $776=(($exprs)|0); + var $777=HEAP32[(($776)>>2)]; + var $778=$777; + var $779=(($778+60)|0); + var $780=HEAP8[($779)]; + var $781=(($780) & 1); + if ($781) { __label__ = 103; break; } else { __label__ = 106; break; } + case 103: + var $783=(($exprs+4)|0); + var $784=HEAP32[(($783)>>2)]; + var $785=$784; + var $786=(($785+12)|0); + var $787=HEAP32[(($786)>>2)]; + var $788=(($787)|0)==2; + if ($788) { __label__ = 104; break; } else { __label__ = 106; break; } + case 104: + var $790=(($exprs+4)|0); + var $791=HEAP32[(($790)>>2)]; + var $792=$791; + var $793=(($792+60)|0); + var $794=HEAP8[($793)]; + var $795=(($794) & 1); + if ($795) { __label__ = 105; break; } else { __label__ = 106; break; } + case 105: + var $797=$2; + var $798=(($asvalue)|0); + var $799=HEAP32[(($798)>>2)]; + var $800=(($799+64)|0); + var $801=$800; + var $802=(tempDoubleI32[0]=HEAP32[(($801)>>2)],tempDoubleI32[1]=HEAP32[((($801)+(4))>>2)],tempDoubleF64[0]); + var $803=(($asvalue+4)|0); + var $804=HEAP32[(($803)>>2)]; + var $805=(($804+64)|0); + var $806=$805; + var $807=(tempDoubleI32[0]=HEAP32[(($806)>>2)],tempDoubleI32[1]=HEAP32[((($806)+(4))>>2)],tempDoubleF64[0]); + var $808=($802)-($807); + var $809=_parser_const_float($797, $808); + var $810=$809; + $out=$810; + __label__ = 107; break; + case 106: + var $812=(($exprs)|0); + var $813=HEAP32[(($812)>>2)]; + var $814=(($exprs+4)|0); + var $815=HEAP32[(($814)>>2)]; + var $816=(($ctx)|0); + var $817=HEAP32[(($816)>>2)]; + var $818=(($ctx+4)|0); + var $819=HEAP32[(($818)>>2)]; + var $820=_ast_binary_new($817, $819, 8, $813, $815); + var $821=$820; + $out=$821; + __label__ = 107; break; + case 107: + __label__ = 116; break; + case 108: + var $824=(($exprs)|0); + var $825=HEAP32[(($824)>>2)]; + var $826=$825; + var $827=(($826+12)|0); + var $828=HEAP32[(($827)>>2)]; + var $829=(($828)|0)==2; + if ($829) { __label__ = 109; break; } else { __label__ = 113; break; } + case 109: + var $831=(($exprs)|0); + var $832=HEAP32[(($831)>>2)]; + var $833=$832; + var $834=(($833+60)|0); + var $835=HEAP8[($834)]; + var $836=(($835) & 1); + if ($836) { __label__ = 110; break; } else { __label__ = 113; break; } + case 110: + var $838=(($exprs+4)|0); + var $839=HEAP32[(($838)>>2)]; + var $840=$839; + var $841=(($840+12)|0); + var $842=HEAP32[(($841)>>2)]; + var $843=(($842)|0)==2; + if ($843) { __label__ = 111; break; } else { __label__ = 113; break; } + case 111: + var $845=(($exprs+4)|0); + var $846=HEAP32[(($845)>>2)]; + var $847=$846; + var $848=(($847+60)|0); + var $849=HEAP8[($848)]; + var $850=(($849) & 1); + if ($850) { __label__ = 112; break; } else { __label__ = 113; break; } + case 112: + var $852=$2; + var $853=(($asvalue)|0); + var $854=HEAP32[(($853)>>2)]; + var $855=(($854+64)|0); + var $856=$855; + var $857=(($asvalue+4)|0); + var $858=HEAP32[(($857)>>2)]; + var $859=(($858+64)|0); + var $860=$859; + var $861=(($856)|0); + var $862=HEAPF32[(($861)>>2)]; + var $863=(($856+4)|0); + var $864=HEAPF32[(($863)>>2)]; + var $865=(($856+8)|0); + var $866=HEAPF32[(($865)>>2)]; + var $867=(($860)|0); + var $868=HEAPF32[(($867)>>2)]; + var $869=(($860+4)|0); + var $870=HEAPF32[(($869)>>2)]; + var $871=(($860+8)|0); + var $872=HEAPF32[(($871)>>2)]; + _vec3_sub($6, $862, $864, $866, $868, $870, $872); + var $873=(($6)|0); + var $874=HEAPF32[(($873)>>2)]; + var $875=(($6+4)|0); + var $876=HEAPF32[(($875)>>2)]; + var $877=(($6+8)|0); + var $878=HEAPF32[(($877)>>2)]; + var $879=_parser_const_vector($852, $874, $876, $878); + var $880=$879; + $out=$880; + __label__ = 114; break; + case 113: + var $882=(($exprs)|0); + var $883=HEAP32[(($882)>>2)]; + var $884=(($exprs+4)|0); + var $885=HEAP32[(($884)>>2)]; + var $886=(($ctx)|0); + var $887=HEAP32[(($886)>>2)]; + var $888=(($ctx+4)|0); + var $889=HEAP32[(($888)>>2)]; + var $890=_ast_binary_new($887, $889, 9, $883, $885); + var $891=$890; + $out=$891; + __label__ = 114; break; + case 114: + __label__ = 116; break; + case 115: + var $894=$2; + var $895=(($exprs+4)|0); + var $896=HEAP32[(($895)>>2)]; + var $897=$896; + var $898=(($897+24)|0); + var $899=HEAP32[(($898)>>2)]; + var $900=((_type_name+($899<<2))|0); + var $901=HEAP32[(($900)>>2)]; + var $902=(($exprs)|0); + var $903=HEAP32[(($902)>>2)]; + var $904=$903; + var $905=(($904+24)|0); + var $906=HEAP32[(($905)>>2)]; + var $907=((_type_name+($906<<2))|0); + var $908=HEAP32[(($907)>>2)]; + _parseerror($894, ((STRING_TABLE.__str78650)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$901,HEAP32[(((tempInt)+(4))>>2)]=$908,tempInt)); + $1=0; + __label__ = 254; break; + case 116: + __label__ = 251; break; + case 117: + var $911=(($exprs)|0); + var $912=HEAP32[(($911)>>2)]; + var $913=$912; + var $914=(($913+24)|0); + var $915=HEAP32[(($914)>>2)]; + var $916=(($exprs+4)|0); + var $917=HEAP32[(($916)>>2)]; + var $918=$917; + var $919=(($918+24)|0); + var $920=HEAP32[(($919)>>2)]; + var $921=(($915)|0)!=(($920)|0); + if ($921) { __label__ = 118; break; } else { __label__ = 123; break; } + case 118: + var $923=(($exprs)|0); + var $924=HEAP32[(($923)>>2)]; + var $925=$924; + var $926=(($925+24)|0); + var $927=HEAP32[(($926)>>2)]; + var $928=(($927)|0)!=3; + if ($928) { __label__ = 119; break; } else { __label__ = 123; break; } + case 119: + var $930=(($exprs)|0); + var $931=HEAP32[(($930)>>2)]; + var $932=$931; + var $933=(($932+24)|0); + var $934=HEAP32[(($933)>>2)]; + var $935=(($934)|0)!=2; + if ($935) { __label__ = 120; break; } else { __label__ = 123; break; } + case 120: + var $937=(($exprs+4)|0); + var $938=HEAP32[(($937)>>2)]; + var $939=$938; + var $940=(($939+24)|0); + var $941=HEAP32[(($940)>>2)]; + var $942=(($941)|0)!=3; + if ($942) { __label__ = 121; break; } else { __label__ = 123; break; } + case 121: + var $944=(($exprs+4)|0); + var $945=HEAP32[(($944)>>2)]; + var $946=$945; + var $947=(($946+24)|0); + var $948=HEAP32[(($947)>>2)]; + var $949=(($948)|0)!=2; + if ($949) { __label__ = 122; break; } else { __label__ = 123; break; } + case 122: + var $951=$2; + var $952=(($exprs+4)|0); + var $953=HEAP32[(($952)>>2)]; + var $954=$953; + var $955=(($954+24)|0); + var $956=HEAP32[(($955)>>2)]; + var $957=((_type_name+($956<<2))|0); + var $958=HEAP32[(($957)>>2)]; + var $959=(($exprs)|0); + var $960=HEAP32[(($959)>>2)]; + var $961=$960; + var $962=(($961+24)|0); + var $963=HEAP32[(($962)>>2)]; + var $964=((_type_name+($963<<2))|0); + var $965=HEAP32[(($964)>>2)]; + _parseerror($951, ((STRING_TABLE.__str79651)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$958,HEAP32[(((tempInt)+(4))>>2)]=$965,tempInt)); + $1=0; + __label__ = 254; break; + case 123: + var $967=(($exprs)|0); + var $968=HEAP32[(($967)>>2)]; + var $969=$968; + var $970=(($969+24)|0); + var $971=HEAP32[(($970)>>2)]; + if ((($971)|0) == 2) { + __label__ = 124; break; + } + else if ((($971)|0) == 3) { + __label__ = 140; break; + } + else { + __label__ = 156; break; + } + + case 124: + var $973=(($exprs+4)|0); + var $974=HEAP32[(($973)>>2)]; + var $975=$974; + var $976=(($975+24)|0); + var $977=HEAP32[(($976)>>2)]; + var $978=(($977)|0)==3; + if ($978) { __label__ = 125; break; } else { __label__ = 132; break; } + case 125: + var $980=(($exprs)|0); + var $981=HEAP32[(($980)>>2)]; + var $982=$981; + var $983=(($982+12)|0); + var $984=HEAP32[(($983)>>2)]; + var $985=(($984)|0)==2; + if ($985) { __label__ = 126; break; } else { __label__ = 130; break; } + case 126: + var $987=(($exprs)|0); + var $988=HEAP32[(($987)>>2)]; + var $989=$988; + var $990=(($989+60)|0); + var $991=HEAP8[($990)]; + var $992=(($991) & 1); + if ($992) { __label__ = 127; break; } else { __label__ = 130; break; } + case 127: + var $994=(($exprs+4)|0); + var $995=HEAP32[(($994)>>2)]; + var $996=$995; + var $997=(($996+12)|0); + var $998=HEAP32[(($997)>>2)]; + var $999=(($998)|0)==2; + if ($999) { __label__ = 128; break; } else { __label__ = 130; break; } + case 128: + var $1001=(($exprs+4)|0); + var $1002=HEAP32[(($1001)>>2)]; + var $1003=$1002; + var $1004=(($1003+60)|0); + var $1005=HEAP8[($1004)]; + var $1006=(($1005) & 1); + if ($1006) { __label__ = 129; break; } else { __label__ = 130; break; } + case 129: + var $1008=$2; + var $1009=(($asvalue+4)|0); + var $1010=HEAP32[(($1009)>>2)]; + var $1011=(($1010+64)|0); + var $1012=$1011; + var $1013=(($asvalue)|0); + var $1014=HEAP32[(($1013)>>2)]; + var $1015=(($1014+64)|0); + var $1016=$1015; + var $1017=(tempDoubleI32[0]=HEAP32[(($1016)>>2)],tempDoubleI32[1]=HEAP32[((($1016)+(4))>>2)],tempDoubleF64[0]); + var $1018=$1017; + var $1019=(($1012)|0); + var $1020=HEAPF32[(($1019)>>2)]; + var $1021=(($1012+4)|0); + var $1022=HEAPF32[(($1021)>>2)]; + var $1023=(($1012+8)|0); + var $1024=HEAPF32[(($1023)>>2)]; + _vec3_mulvf($7, $1020, $1022, $1024, $1018); + var $1025=(($7)|0); + var $1026=HEAPF32[(($1025)>>2)]; + var $1027=(($7+4)|0); + var $1028=HEAPF32[(($1027)>>2)]; + var $1029=(($7+8)|0); + var $1030=HEAPF32[(($1029)>>2)]; + var $1031=_parser_const_vector($1008, $1026, $1028, $1030); + var $1032=$1031; + $out=$1032; + __label__ = 131; break; + case 130: + var $1034=(($exprs)|0); + var $1035=HEAP32[(($1034)>>2)]; + var $1036=(($exprs+4)|0); + var $1037=HEAP32[(($1036)>>2)]; + var $1038=(($ctx)|0); + var $1039=HEAP32[(($1038)>>2)]; + var $1040=(($ctx+4)|0); + var $1041=HEAP32[(($1040)>>2)]; + var $1042=_ast_binary_new($1039, $1041, 3, $1035, $1037); + var $1043=$1042; + $out=$1043; + __label__ = 131; break; + case 131: + __label__ = 139; break; + case 132: + var $1046=(($exprs)|0); + var $1047=HEAP32[(($1046)>>2)]; + var $1048=$1047; + var $1049=(($1048+12)|0); + var $1050=HEAP32[(($1049)>>2)]; + var $1051=(($1050)|0)==2; + if ($1051) { __label__ = 133; break; } else { __label__ = 137; break; } + case 133: + var $1053=(($exprs)|0); + var $1054=HEAP32[(($1053)>>2)]; + var $1055=$1054; + var $1056=(($1055+60)|0); + var $1057=HEAP8[($1056)]; + var $1058=(($1057) & 1); + if ($1058) { __label__ = 134; break; } else { __label__ = 137; break; } + case 134: + var $1060=(($exprs+4)|0); + var $1061=HEAP32[(($1060)>>2)]; + var $1062=$1061; + var $1063=(($1062+12)|0); + var $1064=HEAP32[(($1063)>>2)]; + var $1065=(($1064)|0)==2; + if ($1065) { __label__ = 135; break; } else { __label__ = 137; break; } + case 135: + var $1067=(($exprs+4)|0); + var $1068=HEAP32[(($1067)>>2)]; + var $1069=$1068; + var $1070=(($1069+60)|0); + var $1071=HEAP8[($1070)]; + var $1072=(($1071) & 1); + if ($1072) { __label__ = 136; break; } else { __label__ = 137; break; } + case 136: + var $1074=$2; + var $1075=(($asvalue)|0); + var $1076=HEAP32[(($1075)>>2)]; + var $1077=(($1076+64)|0); + var $1078=$1077; + var $1079=(tempDoubleI32[0]=HEAP32[(($1078)>>2)],tempDoubleI32[1]=HEAP32[((($1078)+(4))>>2)],tempDoubleF64[0]); + var $1080=(($asvalue+4)|0); + var $1081=HEAP32[(($1080)>>2)]; + var $1082=(($1081+64)|0); + var $1083=$1082; + var $1084=(tempDoubleI32[0]=HEAP32[(($1083)>>2)],tempDoubleI32[1]=HEAP32[((($1083)+(4))>>2)],tempDoubleF64[0]); + var $1085=($1079)*($1084); + var $1086=_parser_const_float($1074, $1085); + var $1087=$1086; + $out=$1087; + __label__ = 138; break; + case 137: + var $1089=(($exprs)|0); + var $1090=HEAP32[(($1089)>>2)]; + var $1091=(($exprs+4)|0); + var $1092=HEAP32[(($1091)>>2)]; + var $1093=(($ctx)|0); + var $1094=HEAP32[(($1093)>>2)]; + var $1095=(($ctx+4)|0); + var $1096=HEAP32[(($1095)>>2)]; + var $1097=_ast_binary_new($1094, $1096, 1, $1090, $1092); + var $1098=$1097; + $out=$1098; + __label__ = 138; break; + case 138: + __label__ = 139; break; + case 139: + __label__ = 157; break; + case 140: + var $1102=(($exprs+4)|0); + var $1103=HEAP32[(($1102)>>2)]; + var $1104=$1103; + var $1105=(($1104+24)|0); + var $1106=HEAP32[(($1105)>>2)]; + var $1107=(($1106)|0)==2; + if ($1107) { __label__ = 141; break; } else { __label__ = 148; break; } + case 141: + var $1109=(($exprs)|0); + var $1110=HEAP32[(($1109)>>2)]; + var $1111=$1110; + var $1112=(($1111+12)|0); + var $1113=HEAP32[(($1112)>>2)]; + var $1114=(($1113)|0)==2; + if ($1114) { __label__ = 142; break; } else { __label__ = 146; break; } + case 142: + var $1116=(($exprs)|0); + var $1117=HEAP32[(($1116)>>2)]; + var $1118=$1117; + var $1119=(($1118+60)|0); + var $1120=HEAP8[($1119)]; + var $1121=(($1120) & 1); + if ($1121) { __label__ = 143; break; } else { __label__ = 146; break; } + case 143: + var $1123=(($exprs+4)|0); + var $1124=HEAP32[(($1123)>>2)]; + var $1125=$1124; + var $1126=(($1125+12)|0); + var $1127=HEAP32[(($1126)>>2)]; + var $1128=(($1127)|0)==2; + if ($1128) { __label__ = 144; break; } else { __label__ = 146; break; } + case 144: + var $1130=(($exprs+4)|0); + var $1131=HEAP32[(($1130)>>2)]; + var $1132=$1131; + var $1133=(($1132+60)|0); + var $1134=HEAP8[($1133)]; + var $1135=(($1134) & 1); + if ($1135) { __label__ = 145; break; } else { __label__ = 146; break; } + case 145: + var $1137=$2; + var $1138=(($asvalue)|0); + var $1139=HEAP32[(($1138)>>2)]; + var $1140=(($1139+64)|0); + var $1141=$1140; + var $1142=(($asvalue+4)|0); + var $1143=HEAP32[(($1142)>>2)]; + var $1144=(($1143+64)|0); + var $1145=$1144; + var $1146=(tempDoubleI32[0]=HEAP32[(($1145)>>2)],tempDoubleI32[1]=HEAP32[((($1145)+(4))>>2)],tempDoubleF64[0]); + var $1147=$1146; + var $1148=(($1141)|0); + var $1149=HEAPF32[(($1148)>>2)]; + var $1150=(($1141+4)|0); + var $1151=HEAPF32[(($1150)>>2)]; + var $1152=(($1141+8)|0); + var $1153=HEAPF32[(($1152)>>2)]; + _vec3_mulvf($8, $1149, $1151, $1153, $1147); + var $1154=(($8)|0); + var $1155=HEAPF32[(($1154)>>2)]; + var $1156=(($8+4)|0); + var $1157=HEAPF32[(($1156)>>2)]; + var $1158=(($8+8)|0); + var $1159=HEAPF32[(($1158)>>2)]; + var $1160=_parser_const_vector($1137, $1155, $1157, $1159); + var $1161=$1160; + $out=$1161; + __label__ = 147; break; + case 146: + var $1163=(($exprs)|0); + var $1164=HEAP32[(($1163)>>2)]; + var $1165=(($exprs+4)|0); + var $1166=HEAP32[(($1165)>>2)]; + var $1167=(($ctx)|0); + var $1168=HEAP32[(($1167)>>2)]; + var $1169=(($ctx+4)|0); + var $1170=HEAP32[(($1169)>>2)]; + var $1171=_ast_binary_new($1168, $1170, 4, $1164, $1166); + var $1172=$1171; + $out=$1172; + __label__ = 147; break; + case 147: + __label__ = 155; break; + case 148: + var $1175=(($exprs)|0); + var $1176=HEAP32[(($1175)>>2)]; + var $1177=$1176; + var $1178=(($1177+12)|0); + var $1179=HEAP32[(($1178)>>2)]; + var $1180=(($1179)|0)==2; + if ($1180) { __label__ = 149; break; } else { __label__ = 153; break; } + case 149: + var $1182=(($exprs)|0); + var $1183=HEAP32[(($1182)>>2)]; + var $1184=$1183; + var $1185=(($1184+60)|0); + var $1186=HEAP8[($1185)]; + var $1187=(($1186) & 1); + if ($1187) { __label__ = 150; break; } else { __label__ = 153; break; } + case 150: + var $1189=(($exprs+4)|0); + var $1190=HEAP32[(($1189)>>2)]; + var $1191=$1190; + var $1192=(($1191+12)|0); + var $1193=HEAP32[(($1192)>>2)]; + var $1194=(($1193)|0)==2; + if ($1194) { __label__ = 151; break; } else { __label__ = 153; break; } + case 151: + var $1196=(($exprs+4)|0); + var $1197=HEAP32[(($1196)>>2)]; + var $1198=$1197; + var $1199=(($1198+60)|0); + var $1200=HEAP8[($1199)]; + var $1201=(($1200) & 1); + if ($1201) { __label__ = 152; break; } else { __label__ = 153; break; } + case 152: + var $1203=$2; + var $1204=(($asvalue)|0); + var $1205=HEAP32[(($1204)>>2)]; + var $1206=(($1205+64)|0); + var $1207=$1206; + var $1208=(($asvalue+4)|0); + var $1209=HEAP32[(($1208)>>2)]; + var $1210=(($1209+64)|0); + var $1211=$1210; + var $1212=(($1207)|0); + var $1213=HEAPF32[(($1212)>>2)]; + var $1214=(($1207+4)|0); + var $1215=HEAPF32[(($1214)>>2)]; + var $1216=(($1207+8)|0); + var $1217=HEAPF32[(($1216)>>2)]; + var $1218=(($1211)|0); + var $1219=HEAPF32[(($1218)>>2)]; + var $1220=(($1211+4)|0); + var $1221=HEAPF32[(($1220)>>2)]; + var $1222=(($1211+8)|0); + var $1223=HEAPF32[(($1222)>>2)]; + var $1224=_vec3_mulvv($1213, $1215, $1217, $1219, $1221, $1223); + var $1225=$1224; + var $1226=_parser_const_float($1203, $1225); + var $1227=$1226; + $out=$1227; + __label__ = 154; break; + case 153: + var $1229=(($exprs)|0); + var $1230=HEAP32[(($1229)>>2)]; + var $1231=(($exprs+4)|0); + var $1232=HEAP32[(($1231)>>2)]; + var $1233=(($ctx)|0); + var $1234=HEAP32[(($1233)>>2)]; + var $1235=(($ctx+4)|0); + var $1236=HEAP32[(($1235)>>2)]; + var $1237=_ast_binary_new($1234, $1236, 2, $1230, $1232); + var $1238=$1237; + $out=$1238; + __label__ = 154; break; + case 154: + __label__ = 155; break; + case 155: + __label__ = 157; break; + case 156: + var $1242=$2; + var $1243=(($exprs+4)|0); + var $1244=HEAP32[(($1243)>>2)]; + var $1245=$1244; + var $1246=(($1245+24)|0); + var $1247=HEAP32[(($1246)>>2)]; + var $1248=((_type_name+($1247<<2))|0); + var $1249=HEAP32[(($1248)>>2)]; + var $1250=(($exprs)|0); + var $1251=HEAP32[(($1250)>>2)]; + var $1252=$1251; + var $1253=(($1252+24)|0); + var $1254=HEAP32[(($1253)>>2)]; + var $1255=((_type_name+($1254<<2))|0); + var $1256=HEAP32[(($1255)>>2)]; + _parseerror($1242, ((STRING_TABLE.__str79651)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1249,HEAP32[(((tempInt)+(4))>>2)]=$1256,tempInt)); + $1=0; + __label__ = 254; break; + case 157: + __label__ = 251; break; + case 158: + var $1259=(($exprs)|0); + var $1260=HEAP32[(($1259)>>2)]; + var $1261=$1260; + var $1262=(($1261+24)|0); + var $1263=HEAP32[(($1262)>>2)]; + var $1264=(($exprs+4)|0); + var $1265=HEAP32[(($1264)>>2)]; + var $1266=$1265; + var $1267=(($1266+24)|0); + var $1268=HEAP32[(($1267)>>2)]; + var $1269=(($1263)|0)!=(($1268)|0); + if ($1269) { __label__ = 160; break; } else { __label__ = 159; break; } + case 159: + var $1271=(($exprs)|0); + var $1272=HEAP32[(($1271)>>2)]; + var $1273=$1272; + var $1274=(($1273+24)|0); + var $1275=HEAP32[(($1274)>>2)]; + var $1276=(($1275)|0)!=2; + if ($1276) { __label__ = 160; break; } else { __label__ = 161; break; } + case 160: + var $1278=$2; + var $1279=(($exprs)|0); + var $1280=HEAP32[(($1279)>>2)]; + var $1281=$1280; + var $1282=(($1281+24)|0); + var $1283=HEAP32[(($1282)>>2)]; + var $1284=((_type_name+($1283<<2))|0); + var $1285=HEAP32[(($1284)>>2)]; + var $1286=(($exprs+4)|0); + var $1287=HEAP32[(($1286)>>2)]; + var $1288=$1287; + var $1289=(($1288+24)|0); + var $1290=HEAP32[(($1289)>>2)]; + var $1291=((_type_name+($1290<<2))|0); + var $1292=HEAP32[(($1291)>>2)]; + _parseerror($1278, ((STRING_TABLE.__str80652)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1285,HEAP32[(((tempInt)+(4))>>2)]=$1292,tempInt)); + $1=0; + __label__ = 254; break; + case 161: + var $1294=(($exprs)|0); + var $1295=HEAP32[(($1294)>>2)]; + var $1296=$1295; + var $1297=(($1296+12)|0); + var $1298=HEAP32[(($1297)>>2)]; + var $1299=(($1298)|0)==2; + if ($1299) { __label__ = 162; break; } else { __label__ = 166; break; } + case 162: + var $1301=(($exprs)|0); + var $1302=HEAP32[(($1301)>>2)]; + var $1303=$1302; + var $1304=(($1303+60)|0); + var $1305=HEAP8[($1304)]; + var $1306=(($1305) & 1); + if ($1306) { __label__ = 163; break; } else { __label__ = 166; break; } + case 163: + var $1308=(($exprs+4)|0); + var $1309=HEAP32[(($1308)>>2)]; + var $1310=$1309; + var $1311=(($1310+12)|0); + var $1312=HEAP32[(($1311)>>2)]; + var $1313=(($1312)|0)==2; + if ($1313) { __label__ = 164; break; } else { __label__ = 166; break; } + case 164: + var $1315=(($exprs+4)|0); + var $1316=HEAP32[(($1315)>>2)]; + var $1317=$1316; + var $1318=(($1317+60)|0); + var $1319=HEAP8[($1318)]; + var $1320=(($1319) & 1); + if ($1320) { __label__ = 165; break; } else { __label__ = 166; break; } + case 165: + var $1322=$2; + var $1323=(($asvalue)|0); + var $1324=HEAP32[(($1323)>>2)]; + var $1325=(($1324+64)|0); + var $1326=$1325; + var $1327=(tempDoubleI32[0]=HEAP32[(($1326)>>2)],tempDoubleI32[1]=HEAP32[((($1326)+(4))>>2)],tempDoubleF64[0]); + var $1328=(($asvalue+4)|0); + var $1329=HEAP32[(($1328)>>2)]; + var $1330=(($1329+64)|0); + var $1331=$1330; + var $1332=(tempDoubleI32[0]=HEAP32[(($1331)>>2)],tempDoubleI32[1]=HEAP32[((($1331)+(4))>>2)],tempDoubleF64[0]); + var $1333=($1327)/($1332); + var $1334=_parser_const_float($1322, $1333); + var $1335=$1334; + $out=$1335; + __label__ = 167; break; + case 166: + var $1337=(($exprs)|0); + var $1338=HEAP32[(($1337)>>2)]; + var $1339=(($exprs+4)|0); + var $1340=HEAP32[(($1339)>>2)]; + var $1341=(($ctx)|0); + var $1342=HEAP32[(($1341)>>2)]; + var $1343=(($ctx+4)|0); + var $1344=HEAP32[(($1343)>>2)]; + var $1345=_ast_binary_new($1342, $1344, 5, $1338, $1340); + var $1346=$1345; + $out=$1346; + __label__ = 167; break; + case 167: + __label__ = 251; break; + case 168: + var $1349=$2; + _parseerror($1349, ((STRING_TABLE.__str81653)|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)); + $1=0; + __label__ = 254; break; + case 169: + var $1351=(($exprs)|0); + var $1352=HEAP32[(($1351)>>2)]; + var $1353=$1352; + var $1354=(($1353+24)|0); + var $1355=HEAP32[(($1354)>>2)]; + var $1356=(($exprs+4)|0); + var $1357=HEAP32[(($1356)>>2)]; + var $1358=$1357; + var $1359=(($1358+24)|0); + var $1360=HEAP32[(($1359)>>2)]; + var $1361=(($1355)|0)!=(($1360)|0); + if ($1361) { __label__ = 171; break; } else { __label__ = 170; break; } + case 170: + var $1363=(($exprs)|0); + var $1364=HEAP32[(($1363)>>2)]; + var $1365=$1364; + var $1366=(($1365+24)|0); + var $1367=HEAP32[(($1366)>>2)]; + var $1368=(($1367)|0)!=2; + if ($1368) { __label__ = 171; break; } else { __label__ = 172; break; } + case 171: + var $1370=$2; + var $1371=(($exprs)|0); + var $1372=HEAP32[(($1371)>>2)]; + var $1373=$1372; + var $1374=(($1373+24)|0); + var $1375=HEAP32[(($1374)>>2)]; + var $1376=((_type_name+($1375<<2))|0); + var $1377=HEAP32[(($1376)>>2)]; + var $1378=(($exprs+4)|0); + var $1379=HEAP32[(($1378)>>2)]; + var $1380=$1379; + var $1381=(($1380+24)|0); + var $1382=HEAP32[(($1381)>>2)]; + var $1383=((_type_name+($1382<<2))|0); + var $1384=HEAP32[(($1383)>>2)]; + _parseerror($1370, ((STRING_TABLE.__str82654)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1377,HEAP32[(((tempInt)+(4))>>2)]=$1384,tempInt)); + $1=0; + __label__ = 254; break; + case 172: + var $1386=(($exprs)|0); + var $1387=HEAP32[(($1386)>>2)]; + var $1388=$1387; + var $1389=(($1388+12)|0); + var $1390=HEAP32[(($1389)>>2)]; + var $1391=(($1390)|0)==2; + if ($1391) { __label__ = 173; break; } else { __label__ = 180; break; } + case 173: + var $1393=(($exprs)|0); + var $1394=HEAP32[(($1393)>>2)]; + var $1395=$1394; + var $1396=(($1395+60)|0); + var $1397=HEAP8[($1396)]; + var $1398=(($1397) & 1); + if ($1398) { __label__ = 174; break; } else { __label__ = 180; break; } + case 174: + var $1400=(($exprs+4)|0); + var $1401=HEAP32[(($1400)>>2)]; + var $1402=$1401; + var $1403=(($1402+12)|0); + var $1404=HEAP32[(($1403)>>2)]; + var $1405=(($1404)|0)==2; + if ($1405) { __label__ = 175; break; } else { __label__ = 180; break; } + case 175: + var $1407=(($exprs+4)|0); + var $1408=HEAP32[(($1407)>>2)]; + var $1409=$1408; + var $1410=(($1409+60)|0); + var $1411=HEAP8[($1410)]; + var $1412=(($1411) & 1); + if ($1412) { __label__ = 176; break; } else { __label__ = 180; break; } + case 176: + var $1414=$2; + var $1415=$op; + var $1416=(($1415+8)|0); + var $1417=HEAP32[(($1416)>>2)]; + var $1418=(($1417)|0)==124; + if ($1418) { __label__ = 177; break; } else { __label__ = 178; break; } + case 177: + var $1420=(($asvalue)|0); + var $1421=HEAP32[(($1420)>>2)]; + var $1422=(($1421+64)|0); + var $1423=$1422; + var $1424=(tempDoubleI32[0]=HEAP32[(($1423)>>2)],tempDoubleI32[1]=HEAP32[((($1423)+(4))>>2)],tempDoubleF64[0]); + var $1425=(($1424)&-1); + var $1426=(($asvalue+4)|0); + var $1427=HEAP32[(($1426)>>2)]; + var $1428=(($1427+64)|0); + var $1429=$1428; + var $1430=(tempDoubleI32[0]=HEAP32[(($1429)>>2)],tempDoubleI32[1]=HEAP32[((($1429)+(4))>>2)],tempDoubleF64[0]); + var $1431=(($1430)&-1); + var $1432=$1425 | $1431; + var $1433=(($1432)|0); + var $1450 = $1433;__label__ = 179; break; + case 178: + var $1435=(($asvalue)|0); + var $1436=HEAP32[(($1435)>>2)]; + var $1437=(($1436+64)|0); + var $1438=$1437; + var $1439=(tempDoubleI32[0]=HEAP32[(($1438)>>2)],tempDoubleI32[1]=HEAP32[((($1438)+(4))>>2)],tempDoubleF64[0]); + var $1440=(($1439)&-1); + var $1441=(($asvalue+4)|0); + var $1442=HEAP32[(($1441)>>2)]; + var $1443=(($1442+64)|0); + var $1444=$1443; + var $1445=(tempDoubleI32[0]=HEAP32[(($1444)>>2)],tempDoubleI32[1]=HEAP32[((($1444)+(4))>>2)],tempDoubleF64[0]); + var $1446=(($1445)&-1); + var $1447=$1440 & $1446; + var $1448=(($1447)|0); + var $1450 = $1448;__label__ = 179; break; + case 179: + var $1450; + var $1451=$1450; + var $1452=_parser_const_float($1414, $1451); + var $1453=$1452; + $out=$1453; + __label__ = 181; break; + case 180: + var $1455=$op; + var $1456=(($1455+8)|0); + var $1457=HEAP32[(($1456)>>2)]; + var $1458=(($1457)|0)==124; + var $1459=$1458 ? 65 : 64; + var $1460=(($exprs)|0); + var $1461=HEAP32[(($1460)>>2)]; + var $1462=(($exprs+4)|0); + var $1463=HEAP32[(($1462)>>2)]; + var $1464=(($ctx)|0); + var $1465=HEAP32[(($1464)>>2)]; + var $1466=(($ctx+4)|0); + var $1467=HEAP32[(($1466)>>2)]; + var $1468=_ast_binary_new($1465, $1467, $1459, $1461, $1463); + var $1469=$1468; + $out=$1469; + __label__ = 181; break; + case 181: + __label__ = 251; break; + case 182: + var $1472=$2; + _parseerror($1472, ((STRING_TABLE.__str83655)|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)); + $1=0; + __label__ = 254; break; + case 183: + var $1474=$2; + _parseerror($1474, ((STRING_TABLE.__str84656)|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)); + $1=0; + __label__ = 254; break; + case 184: + var $1476=$generated_op; + var $1477=((($1476)+(1))|0); + $generated_op=$1477; + __label__ = 185; break; + case 185: + var $1479=$generated_op; + var $1480=((($1479)+(62))|0); + $generated_op=$1480; + var $1481=(($exprs)|0); + var $1482=HEAP32[(($1481)>>2)]; + var $1483=$1482; + var $1484=(($1483+24)|0); + var $1485=HEAP32[(($1484)>>2)]; + var $1486=(($exprs+4)|0); + var $1487=HEAP32[(($1486)>>2)]; + var $1488=$1487; + var $1489=(($1488+24)|0); + var $1490=HEAP32[(($1489)>>2)]; + var $1491=(($1485)|0)!=(($1490)|0); + if ($1491) { __label__ = 187; break; } else { __label__ = 186; break; } + case 186: + var $1493=(($exprs)|0); + var $1494=HEAP32[(($1493)>>2)]; + var $1495=$1494; + var $1496=(($1495+24)|0); + var $1497=HEAP32[(($1496)>>2)]; + var $1498=(($1497)|0)!=2; + if ($1498) { __label__ = 187; break; } else { __label__ = 188; break; } + case 187: + var $1500=$2; + var $1501=(($exprs)|0); + var $1502=HEAP32[(($1501)>>2)]; + var $1503=$1502; + var $1504=(($1503+24)|0); + var $1505=HEAP32[(($1504)>>2)]; + var $1506=((_type_name+($1505<<2))|0); + var $1507=HEAP32[(($1506)>>2)]; + var $1508=(($exprs+4)|0); + var $1509=HEAP32[(($1508)>>2)]; + var $1510=$1509; + var $1511=(($1510+24)|0); + var $1512=HEAP32[(($1511)>>2)]; + var $1513=((_type_name+($1512<<2))|0); + var $1514=HEAP32[(($1513)>>2)]; + _parseerror($1500, ((STRING_TABLE.__str85657)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1507,HEAP32[(((tempInt)+(4))>>2)]=$1514,tempInt)); + var $1515=$2; + _parseerror($1515, ((STRING_TABLE.__str86658)|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)); + var $1516=$2; + _parseerror($1516, ((STRING_TABLE.__str87659)|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)); + $1=0; + __label__ = 254; break; + case 188: + var $1518=HEAP32[((_opts_standard)>>2)]; + var $1519=(($1518)|0)==3; + if ($1519) { __label__ = 189; break; } else { __label__ = 190; break; } + case 189: + var $1521=_printf(((STRING_TABLE.__str88660)|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)); + __label__ = 190; break; + case 190: + var $1523=(($exprs)|0); + var $1524=HEAP32[(($1523)>>2)]; + var $1525=$1524; + var $1526=(($1525+12)|0); + var $1527=HEAP32[(($1526)>>2)]; + var $1528=(($1527)|0)==2; + if ($1528) { __label__ = 191; break; } else { __label__ = 202; break; } + case 191: + var $1530=(($exprs)|0); + var $1531=HEAP32[(($1530)>>2)]; + var $1532=$1531; + var $1533=(($1532+60)|0); + var $1534=HEAP8[($1533)]; + var $1535=(($1534) & 1); + if ($1535) { __label__ = 192; break; } else { __label__ = 202; break; } + case 192: + var $1537=(($exprs+4)|0); + var $1538=HEAP32[(($1537)>>2)]; + var $1539=$1538; + var $1540=(($1539+12)|0); + var $1541=HEAP32[(($1540)>>2)]; + var $1542=(($1541)|0)==2; + if ($1542) { __label__ = 193; break; } else { __label__ = 202; break; } + case 193: + var $1544=(($exprs+4)|0); + var $1545=HEAP32[(($1544)>>2)]; + var $1546=$1545; + var $1547=(($1546+60)|0); + var $1548=HEAP8[($1547)]; + var $1549=(($1548) & 1); + if ($1549) { __label__ = 194; break; } else { __label__ = 202; break; } + case 194: + var $1551=$2; + var $1552=$generated_op; + var $1553=(($1552)|0)==63; + if ($1553) { __label__ = 195; break; } else { __label__ = 198; break; } + case 195: + var $1555=(($asvalue)|0); + var $1556=HEAP32[(($1555)>>2)]; + var $1557=(($1556+64)|0); + var $1558=$1557; + var $1559=(tempDoubleI32[0]=HEAP32[(($1558)>>2)],tempDoubleI32[1]=HEAP32[((($1558)+(4))>>2)],tempDoubleF64[0]); + var $1560=$1559 != 0; + if ($1560) { var $1569 = 1;__label__ = 197; break; } else { __label__ = 196; break; } + case 196: + var $1562=(($asvalue+4)|0); + var $1563=HEAP32[(($1562)>>2)]; + var $1564=(($1563+64)|0); + var $1565=$1564; + var $1566=(tempDoubleI32[0]=HEAP32[(($1565)>>2)],tempDoubleI32[1]=HEAP32[((($1565)+(4))>>2)],tempDoubleF64[0]); + var $1567=$1566 != 0; + var $1569 = $1567;__label__ = 197; break; + case 197: + var $1569; + var $1570=(($1569)&1); + var $1589 = $1570;__label__ = 201; break; + case 198: + var $1572=(($asvalue)|0); + var $1573=HEAP32[(($1572)>>2)]; + var $1574=(($1573+64)|0); + var $1575=$1574; + var $1576=(tempDoubleI32[0]=HEAP32[(($1575)>>2)],tempDoubleI32[1]=HEAP32[((($1575)+(4))>>2)],tempDoubleF64[0]); + var $1577=$1576 != 0; + if ($1577) { __label__ = 199; break; } else { var $1586 = 0;__label__ = 200; break; } + case 199: + var $1579=(($asvalue+4)|0); + var $1580=HEAP32[(($1579)>>2)]; + var $1581=(($1580+64)|0); + var $1582=$1581; + var $1583=(tempDoubleI32[0]=HEAP32[(($1582)>>2)],tempDoubleI32[1]=HEAP32[((($1582)+(4))>>2)],tempDoubleF64[0]); + var $1584=$1583 != 0; + var $1586 = $1584;__label__ = 200; break; + case 200: + var $1586; + var $1587=(($1586)&1); + var $1589 = $1587;__label__ = 201; break; + case 201: + var $1589; + var $1590=(($1589)|0); + var $1591=_parser_const_float($1551, $1590); + var $1592=$1591; + $out=$1592; + __label__ = 203; break; + case 202: + var $1594=$generated_op; + var $1595=(($exprs)|0); + var $1596=HEAP32[(($1595)>>2)]; + var $1597=(($exprs+4)|0); + var $1598=HEAP32[(($1597)>>2)]; + var $1599=(($ctx)|0); + var $1600=HEAP32[(($1599)>>2)]; + var $1601=(($ctx+4)|0); + var $1602=HEAP32[(($1601)>>2)]; + var $1603=_ast_binary_new($1600, $1602, $1594, $1596, $1598); + var $1604=$1603; + $out=$1604; + __label__ = 203; break; + case 203: + __label__ = 251; break; + case 204: + var $1607=$generated_op; + var $1608=((($1607)+(1))|0); + $generated_op=$1608; + __label__ = 205; break; + case 205: + var $1610=$generated_op; + var $1611=((($1610)+(1))|0); + $generated_op=$1611; + __label__ = 206; break; + case 206: + var $1613=$generated_op; + var $1614=((($1613)+(1))|0); + $generated_op=$1614; + __label__ = 207; break; + case 207: + var $1616=$generated_op; + var $1617=((($1616)+(20))|0); + $generated_op=$1617; + var $1618=(($exprs)|0); + var $1619=HEAP32[(($1618)>>2)]; + var $1620=$1619; + var $1621=(($1620+24)|0); + var $1622=HEAP32[(($1621)>>2)]; + var $1623=(($exprs+4)|0); + var $1624=HEAP32[(($1623)>>2)]; + var $1625=$1624; + var $1626=(($1625+24)|0); + var $1627=HEAP32[(($1626)>>2)]; + var $1628=(($1622)|0)!=(($1627)|0); + if ($1628) { __label__ = 209; break; } else { __label__ = 208; break; } + case 208: + var $1630=(($exprs)|0); + var $1631=HEAP32[(($1630)>>2)]; + var $1632=$1631; + var $1633=(($1632+24)|0); + var $1634=HEAP32[(($1633)>>2)]; + var $1635=(($1634)|0)!=2; + if ($1635) { __label__ = 209; break; } else { __label__ = 210; break; } + case 209: + var $1637=$2; + var $1638=(($exprs)|0); + var $1639=HEAP32[(($1638)>>2)]; + var $1640=$1639; + var $1641=(($1640+24)|0); + var $1642=HEAP32[(($1641)>>2)]; + var $1643=((_type_name+($1642<<2))|0); + var $1644=HEAP32[(($1643)>>2)]; + var $1645=(($exprs+4)|0); + var $1646=HEAP32[(($1645)>>2)]; + var $1647=$1646; + var $1648=(($1647+24)|0); + var $1649=HEAP32[(($1648)>>2)]; + var $1650=((_type_name+($1649<<2))|0); + var $1651=HEAP32[(($1650)>>2)]; + _parseerror($1637, ((STRING_TABLE.__str89661)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1644,HEAP32[(((tempInt)+(4))>>2)]=$1651,tempInt)); + $1=0; + __label__ = 254; break; + case 210: + var $1653=$generated_op; + var $1654=(($exprs)|0); + var $1655=HEAP32[(($1654)>>2)]; + var $1656=(($exprs+4)|0); + var $1657=HEAP32[(($1656)>>2)]; + var $1658=(($ctx)|0); + var $1659=HEAP32[(($1658)>>2)]; + var $1660=(($ctx+4)|0); + var $1661=HEAP32[(($1660)>>2)]; + var $1662=_ast_binary_new($1659, $1661, $1653, $1655, $1657); + var $1663=$1662; + $out=$1663; + __label__ = 251; break; + case 211: + var $1665=(($exprs)|0); + var $1666=HEAP32[(($1665)>>2)]; + var $1667=$1666; + var $1668=(($1667+24)|0); + var $1669=HEAP32[(($1668)>>2)]; + var $1670=(($exprs+4)|0); + var $1671=HEAP32[(($1670)>>2)]; + var $1672=$1671; + var $1673=(($1672+24)|0); + var $1674=HEAP32[(($1673)>>2)]; + var $1675=(($1669)|0)!=(($1674)|0); + if ($1675) { __label__ = 212; break; } else { __label__ = 213; break; } + case 212: + var $1677=$2; + var $1678=(($exprs)|0); + var $1679=HEAP32[(($1678)>>2)]; + var $1680=$1679; + var $1681=(($1680+24)|0); + var $1682=HEAP32[(($1681)>>2)]; + var $1683=((_type_name+($1682<<2))|0); + var $1684=HEAP32[(($1683)>>2)]; + var $1685=(($exprs+4)|0); + var $1686=HEAP32[(($1685)>>2)]; + var $1687=$1686; + var $1688=(($1687+24)|0); + var $1689=HEAP32[(($1688)>>2)]; + var $1690=((_type_name+($1689<<2))|0); + var $1691=HEAP32[(($1690)>>2)]; + _parseerror($1677, ((STRING_TABLE.__str89661)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1684,HEAP32[(((tempInt)+(4))>>2)]=$1691,tempInt)); + $1=0; + __label__ = 254; break; + case 213: + var $1693=(($exprs)|0); + var $1694=HEAP32[(($1693)>>2)]; + var $1695=$1694; + var $1696=(($1695+24)|0); + var $1697=HEAP32[(($1696)>>2)]; + var $1698=((_type_ne_instr+($1697<<1))|0); + var $1699=HEAP16[(($1698)>>1)]; + var $1700=(($1699)&65535); + var $1701=(($exprs)|0); + var $1702=HEAP32[(($1701)>>2)]; + var $1703=(($exprs+4)|0); + var $1704=HEAP32[(($1703)>>2)]; + var $1705=(($ctx)|0); + var $1706=HEAP32[(($1705)>>2)]; + var $1707=(($ctx+4)|0); + var $1708=HEAP32[(($1707)>>2)]; + var $1709=_ast_binary_new($1706, $1708, $1700, $1702, $1704); + var $1710=$1709; + $out=$1710; + __label__ = 251; break; + case 214: + var $1712=(($exprs)|0); + var $1713=HEAP32[(($1712)>>2)]; + var $1714=$1713; + var $1715=(($1714+24)|0); + var $1716=HEAP32[(($1715)>>2)]; + var $1717=(($exprs+4)|0); + var $1718=HEAP32[(($1717)>>2)]; + var $1719=$1718; + var $1720=(($1719+24)|0); + var $1721=HEAP32[(($1720)>>2)]; + var $1722=(($1716)|0)!=(($1721)|0); + if ($1722) { __label__ = 215; break; } else { __label__ = 216; break; } + case 215: + var $1724=$2; + var $1725=(($exprs)|0); + var $1726=HEAP32[(($1725)>>2)]; + var $1727=$1726; + var $1728=(($1727+24)|0); + var $1729=HEAP32[(($1728)>>2)]; + var $1730=((_type_name+($1729<<2))|0); + var $1731=HEAP32[(($1730)>>2)]; + var $1732=(($exprs+4)|0); + var $1733=HEAP32[(($1732)>>2)]; + var $1734=$1733; + var $1735=(($1734+24)|0); + var $1736=HEAP32[(($1735)>>2)]; + var $1737=((_type_name+($1736<<2))|0); + var $1738=HEAP32[(($1737)>>2)]; + _parseerror($1724, ((STRING_TABLE.__str89661)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1731,HEAP32[(((tempInt)+(4))>>2)]=$1738,tempInt)); + $1=0; + __label__ = 254; break; + case 216: + var $1740=(($exprs)|0); + var $1741=HEAP32[(($1740)>>2)]; + var $1742=$1741; + var $1743=(($1742+24)|0); + var $1744=HEAP32[(($1743)>>2)]; + var $1745=((_type_eq_instr+($1744<<1))|0); + var $1746=HEAP16[(($1745)>>1)]; + var $1747=(($1746)&65535); + var $1748=(($exprs)|0); + var $1749=HEAP32[(($1748)>>2)]; + var $1750=(($exprs+4)|0); + var $1751=HEAP32[(($1750)>>2)]; + var $1752=(($ctx)|0); + var $1753=HEAP32[(($1752)>>2)]; + var $1754=(($ctx+4)|0); + var $1755=HEAP32[(($1754)>>2)]; + var $1756=_ast_binary_new($1753, $1755, $1747, $1749, $1751); + var $1757=$1756; + $out=$1757; + __label__ = 251; break; + case 217: + var $1759=(($exprs)|0); + var $1760=HEAP32[(($1759)>>2)]; + var $1761=$1760; + var $1762=(($1761+12)|0); + var $1763=HEAP32[(($1762)>>2)]; + var $1764=(($1763)|0)==8; + if ($1764) { __label__ = 218; break; } else { __label__ = 228; break; } + case 218: + var $1766=(($exprs)|0); + var $1767=HEAP32[(($1766)>>2)]; + var $1768=$1767; + var $1769=(($1768+60)|0); + var $1770=HEAP32[(($1769)>>2)]; + $field=$1770; + var $1771=(($exprs)|0); + var $1772=HEAP32[(($1771)>>2)]; + var $1773=$1772; + var $1774=(($1773+24)|0); + var $1775=HEAP32[(($1774)>>2)]; + var $1776=((_type_storep_instr+($1775<<1))|0); + var $1777=HEAP16[(($1776)>>1)]; + var $1778=(($1777)&65535); + $assignop=$1778; + var $1779=$field; + var $1780=$1779; + var $1781=(($1780+28)|0); + var $1782=HEAP32[(($1781)>>2)]; + var $1783=(($exprs+4)|0); + var $1784=HEAP32[(($1783)>>2)]; + var $1785=_ast_compare_type($1782, $1784); + if ($1785) { __label__ = 227; break; } else { __label__ = 219; break; } + case 219: + var $1787=$field; + var $1788=$1787; + var $1789=(($1788+28)|0); + var $1790=HEAP32[(($1789)>>2)]; + var $1791=(($ty1)|0); + _ast_type_to_string($1790, $1791, 1024); + var $1792=(($exprs+4)|0); + var $1793=HEAP32[(($1792)>>2)]; + var $1794=(($ty2)|0); + _ast_type_to_string($1793, $1794, 1024); + var $1795=HEAP32[((_opts_standard)>>2)]; + var $1796=(($1795)|0)==0; + if ($1796) { __label__ = 220; break; } else { __label__ = 225; break; } + case 220: + var $1798=$field; + var $1799=$1798; + var $1800=(($1799+28)|0); + var $1801=HEAP32[(($1800)>>2)]; + var $1802=$1801; + var $1803=(($1802+24)|0); + var $1804=HEAP32[(($1803)>>2)]; + var $1805=(($1804)|0)==6; + if ($1805) { __label__ = 221; break; } else { __label__ = 225; break; } + case 221: + var $1807=(($exprs+4)|0); + var $1808=HEAP32[(($1807)>>2)]; + var $1809=$1808; + var $1810=(($1809+24)|0); + var $1811=HEAP32[(($1810)>>2)]; + var $1812=(($1811)|0)==6; + if ($1812) { __label__ = 222; break; } else { __label__ = 225; break; } + case 222: + var $1814=$2; + var $1815=(($ty2)|0); + var $1816=(($ty1)|0); + var $1817=_parsewarning($1814, 16, ((STRING_TABLE.__str90662)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1815,HEAP32[(((tempInt)+(4))>>2)]=$1816,tempInt)); + if ($1817) { __label__ = 223; break; } else { __label__ = 224; break; } + case 223: + var $1819=$2; + var $1820=(($1819+116)|0); + var $1821=HEAP32[(($1820)>>2)]; + var $1822=((($1821)+(1))|0); + HEAP32[(($1820)>>2)]=$1822; + __label__ = 224; break; + case 224: + __label__ = 226; break; + case 225: + var $1825=$2; + var $1826=(($ty2)|0); + var $1827=(($ty1)|0); + _parseerror($1825, ((STRING_TABLE.__str90662)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1826,HEAP32[(((tempInt)+(4))>>2)]=$1827,tempInt)); + __label__ = 226; break; + case 226: + __label__ = 227; break; + case 227: + __label__ = 238; break; + case 228: + var $1831=(($exprs)|0); + var $1832=HEAP32[(($1831)>>2)]; + var $1833=$1832; + var $1834=(($1833+24)|0); + var $1835=HEAP32[(($1834)>>2)]; + var $1836=((_type_store_instr+($1835<<1))|0); + var $1837=HEAP16[(($1836)>>1)]; + var $1838=(($1837)&65535); + $assignop=$1838; + var $1839=(($exprs)|0); + var $1840=HEAP32[(($1839)>>2)]; + var $1841=(($exprs+4)|0); + var $1842=HEAP32[(($1841)>>2)]; + var $1843=_ast_compare_type($1840, $1842); + if ($1843) { __label__ = 237; break; } else { __label__ = 229; break; } + case 229: + var $1845=(($exprs)|0); + var $1846=HEAP32[(($1845)>>2)]; + var $1847=(($ty11)|0); + _ast_type_to_string($1846, $1847, 1024); + var $1848=(($exprs+4)|0); + var $1849=HEAP32[(($1848)>>2)]; + var $1850=(($ty22)|0); + _ast_type_to_string($1849, $1850, 1024); + var $1851=HEAP32[((_opts_standard)>>2)]; + var $1852=(($1851)|0)==0; + if ($1852) { __label__ = 230; break; } else { __label__ = 235; break; } + case 230: + var $1854=(($exprs)|0); + var $1855=HEAP32[(($1854)>>2)]; + var $1856=$1855; + var $1857=(($1856+24)|0); + var $1858=HEAP32[(($1857)>>2)]; + var $1859=(($1858)|0)==6; + if ($1859) { __label__ = 231; break; } else { __label__ = 235; break; } + case 231: + var $1861=(($exprs+4)|0); + var $1862=HEAP32[(($1861)>>2)]; + var $1863=$1862; + var $1864=(($1863+24)|0); + var $1865=HEAP32[(($1864)>>2)]; + var $1866=(($1865)|0)==6; + if ($1866) { __label__ = 232; break; } else { __label__ = 235; break; } + case 232: + var $1868=$2; + var $1869=(($ty22)|0); + var $1870=(($ty11)|0); + var $1871=_parsewarning($1868, 16, ((STRING_TABLE.__str90662)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1869,HEAP32[(((tempInt)+(4))>>2)]=$1870,tempInt)); + if ($1871) { __label__ = 233; break; } else { __label__ = 234; break; } + case 233: + var $1873=$2; + var $1874=(($1873+116)|0); + var $1875=HEAP32[(($1874)>>2)]; + var $1876=((($1875)+(1))|0); + HEAP32[(($1874)>>2)]=$1876; + __label__ = 234; break; + case 234: + __label__ = 236; break; + case 235: + var $1879=$2; + var $1880=(($ty22)|0); + var $1881=(($ty11)|0); + _parseerror($1879, ((STRING_TABLE.__str90662)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1880,HEAP32[(((tempInt)+(4))>>2)]=$1881,tempInt)); + __label__ = 236; break; + case 236: + __label__ = 237; break; + case 237: + __label__ = 238; break; + case 238: + var $1885=$assignop; + var $1886=(($exprs)|0); + var $1887=HEAP32[(($1886)>>2)]; + var $1888=(($exprs+4)|0); + var $1889=HEAP32[(($1888)>>2)]; + var $1890=(($ctx)|0); + var $1891=HEAP32[(($1890)>>2)]; + var $1892=(($ctx+4)|0); + var $1893=HEAP32[(($1892)>>2)]; + var $1894=_ast_store_new($1891, $1893, $1885, $1887, $1889); + var $1895=$1894; + $out=$1895; + __label__ = 251; break; + case 239: + var $1897=(($exprs)|0); + var $1898=HEAP32[(($1897)>>2)]; + var $1899=$1898; + var $1900=(($1899+24)|0); + var $1901=HEAP32[(($1900)>>2)]; + var $1902=(($exprs+4)|0); + var $1903=HEAP32[(($1902)>>2)]; + var $1904=$1903; + var $1905=(($1904+24)|0); + var $1906=HEAP32[(($1905)>>2)]; + var $1907=(($1901)|0)!=(($1906)|0); + if ($1907) { __label__ = 242; break; } else { __label__ = 240; break; } + case 240: + var $1909=(($exprs)|0); + var $1910=HEAP32[(($1909)>>2)]; + var $1911=$1910; + var $1912=(($1911+24)|0); + var $1913=HEAP32[(($1912)>>2)]; + var $1914=(($1913)|0)!=3; + if ($1914) { __label__ = 241; break; } else { __label__ = 243; break; } + case 241: + var $1916=(($exprs)|0); + var $1917=HEAP32[(($1916)>>2)]; + var $1918=$1917; + var $1919=(($1918+24)|0); + var $1920=HEAP32[(($1919)>>2)]; + var $1921=(($1920)|0)!=2; + if ($1921) { __label__ = 242; break; } else { __label__ = 243; break; } + case 242: + var $1923=$2; + var $1924=(($exprs)|0); + var $1925=HEAP32[(($1924)>>2)]; + var $1926=$1925; + var $1927=(($1926+24)|0); + var $1928=HEAP32[(($1927)>>2)]; + var $1929=((_type_name+($1928<<2))|0); + var $1930=HEAP32[(($1929)>>2)]; + var $1931=(($exprs+4)|0); + var $1932=HEAP32[(($1931)>>2)]; + var $1933=$1932; + var $1934=(($1933+24)|0); + var $1935=HEAP32[(($1934)>>2)]; + var $1936=((_type_name+($1935<<2))|0); + var $1937=HEAP32[(($1936)>>2)]; + _parseerror($1923, ((STRING_TABLE.__str91663)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$1930,HEAP32[(((tempInt)+(4))>>2)]=$1937,tempInt)); + $1=0; + __label__ = 254; break; + case 243: + var $1939=(($exprs)|0); + var $1940=HEAP32[(($1939)>>2)]; + var $1941=$1940; + var $1942=(($1941+12)|0); + var $1943=HEAP32[(($1942)>>2)]; + var $1944=(($1943)|0)==8; + if ($1944) { __label__ = 244; break; } else { __label__ = 245; break; } + case 244: + var $1946=(($exprs)|0); + var $1947=HEAP32[(($1946)>>2)]; + var $1948=$1947; + var $1949=(($1948+24)|0); + var $1950=HEAP32[(($1949)>>2)]; + var $1951=((_type_storep_instr+($1950<<1))|0); + var $1952=HEAP16[(($1951)>>1)]; + var $1953=(($1952)&65535); + $assignop=$1953; + __label__ = 246; break; + case 245: + var $1955=(($exprs)|0); + var $1956=HEAP32[(($1955)>>2)]; + var $1957=$1956; + var $1958=(($1957+24)|0); + var $1959=HEAP32[(($1958)>>2)]; + var $1960=((_type_store_instr+($1959<<1))|0); + var $1961=HEAP16[(($1960)>>1)]; + var $1962=(($1961)&65535); + $assignop=$1962; + __label__ = 246; break; + case 246: + var $1964=(($exprs)|0); + var $1965=HEAP32[(($1964)>>2)]; + var $1966=$1965; + var $1967=(($1966+24)|0); + var $1968=HEAP32[(($1967)>>2)]; + if ((($1968)|0) == 2) { + __label__ = 247; break; + } + else if ((($1968)|0) == 3) { + __label__ = 248; break; + } + else { + __label__ = 249; break; + } + + case 247: + var $1970=$assignop; + var $1971=$op; + var $1972=(($1971+8)|0); + var $1973=HEAP32[(($1972)>>2)]; + var $1974=(($1973)|0)==11069; + var $1975=$1974 ? 6 : 8; + var $1976=(($exprs)|0); + var $1977=HEAP32[(($1976)>>2)]; + var $1978=(($exprs+4)|0); + var $1979=HEAP32[(($1978)>>2)]; + var $1980=(($ctx)|0); + var $1981=HEAP32[(($1980)>>2)]; + var $1982=(($ctx+4)|0); + var $1983=HEAP32[(($1982)>>2)]; + var $1984=_ast_binstore_new($1981, $1983, $1970, $1975, $1977, $1979); + var $1985=$1984; + $out=$1985; + __label__ = 250; break; + case 248: + var $1987=$assignop; + var $1988=$op; + var $1989=(($1988+8)|0); + var $1990=HEAP32[(($1989)>>2)]; + var $1991=(($1990)|0)==11069; + var $1992=$1991 ? 7 : 9; + var $1993=(($exprs)|0); + var $1994=HEAP32[(($1993)>>2)]; + var $1995=(($exprs+4)|0); + var $1996=HEAP32[(($1995)>>2)]; + var $1997=(($ctx)|0); + var $1998=HEAP32[(($1997)>>2)]; + var $1999=(($ctx+4)|0); + var $2000=HEAP32[(($1999)>>2)]; + var $2001=_ast_binstore_new($1998, $2000, $1987, $1992, $1994, $1996); + var $2002=$2001; + $out=$2002; + __label__ = 250; break; + case 249: + var $2004=$2; + var $2005=(($exprs)|0); + var $2006=HEAP32[(($2005)>>2)]; + var $2007=$2006; + var $2008=(($2007+24)|0); + var $2009=HEAP32[(($2008)>>2)]; + var $2010=((_type_name+($2009<<2))|0); + var $2011=HEAP32[(($2010)>>2)]; + var $2012=(($exprs+4)|0); + var $2013=HEAP32[(($2012)>>2)]; + var $2014=$2013; + var $2015=(($2014+24)|0); + var $2016=HEAP32[(($2015)>>2)]; + var $2017=((_type_name+($2016<<2))|0); + var $2018=HEAP32[(($2017)>>2)]; + _parseerror($2004, ((STRING_TABLE.__str91663)|0), (tempInt=STACKTOP,STACKTOP += 8,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2011,HEAP32[(((tempInt)+(4))>>2)]=$2018,tempInt)); + $1=0; + __label__ = 254; break; + case 250: + __label__ = 251; break; + case 251: + var $2021=$out; + var $2022=(($2021)|0)!=0; + if ($2022) { __label__ = 253; break; } else { __label__ = 252; break; } + case 252: + var $2024=$2; + var $2025=$op; + var $2026=(($2025)|0); + var $2027=HEAP32[(($2026)>>2)]; + _parseerror($2024, ((STRING_TABLE.__str92664)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$2027,tempInt)); + $1=0; + __label__ = 254; break; + case 253: + var $2029=$3; + var $2030=(($2029+4)|0); + var $2031=HEAP32[(($2030)>>2)]; + var $2032=((($2031)+(1))|0); + HEAP32[(($2030)>>2)]=$2032; + var $2033=$3; + var $2034=(($2033)|0); + var $2035=HEAP32[(($2034)>>2)]; + var $2036=(($2035+($2031)*(28))|0); + var $2037=$out; + var $2038=(($ctx)|0); + var $2039=HEAP32[(($2038)>>2)]; + var $2040=(($ctx+4)|0); + var $2041=HEAP32[(($2040)>>2)]; + _syexp($9, $2039, $2041, $2037); + var $2042=$2036; + var $2043=$9; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($2042)>>2)]=HEAP32[(($2043)>>2)];HEAP32[((($2042)+(4))>>2)]=HEAP32[((($2043)+(4))>>2)];HEAP32[((($2042)+(8))>>2)]=HEAP32[((($2043)+(8))>>2)];HEAP32[((($2042)+(12))>>2)]=HEAP32[((($2043)+(12))>>2)];HEAP32[((($2042)+(16))>>2)]=HEAP32[((($2043)+(16))>>2)];HEAP32[((($2042)+(20))>>2)]=HEAP32[((($2043)+(20))>>2)];HEAP32[((($2042)+(24))>>2)]=HEAP32[((($2043)+(24))>>2)]; + $1=1; + __label__ = 254; break; + case 254: + var $2045=$1; + STACKTOP = __stackBase__; + return $2045; + default: assert(0, "bad label: " + __label__); + } +} +_parser_sy_pop["X"]=1; + +function _syparen($agg_result, $ctx_0, $ctx_1, $p, $off) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $2; + var $e=(__stackBase__)+(8); + var $3=(($ctx)|0); + HEAP32[(($3)>>2)]=$ctx_0; + var $4=(($ctx+4)|0); + HEAP32[(($4)>>2)]=$ctx_1; + $1=$p; + $2=$off; + var $5=(($e)|0); + HEAP32[(($5)>>2)]=0; + var $6=$2; + var $7=(($e+8)|0); + HEAP32[(($7)>>2)]=$6; + var $8=(($e+12)|0); + HEAP32[(($8)>>2)]=0; + var $9=(($e+16)|0); + HEAP32[(($9)>>2)]=0; + var $10=(($e+20)|0); + var $11=$10; + var $12=$ctx; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($11)>>2)]=HEAP32[(($12)>>2)];HEAP32[((($11)+(4))>>2)]=HEAP32[((($12)+(4))>>2)]; + var $13=$1; + var $14=(($e+4)|0); + HEAP32[(($14)>>2)]=$13; + var $15=$agg_result; + var $16=$e; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($15)>>2)]=HEAP32[(($16)>>2)];HEAP32[((($15)+(4))>>2)]=HEAP32[((($16)+(4))>>2)];HEAP32[((($15)+(8))>>2)]=HEAP32[((($16)+(8))>>2)];HEAP32[((($15)+(12))>>2)]=HEAP32[((($16)+(12))>>2)];HEAP32[((($15)+(16))>>2)]=HEAP32[((($16)+(16))>>2)];HEAP32[((($15)+(20))>>2)]=HEAP32[((($16)+(20))>>2)];HEAP32[((($15)+(24))>>2)]=HEAP32[((($16)+(24))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _syop($agg_result, $ctx_0, $ctx_1, $op) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $e=(__stackBase__)+(8); + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + $1=$op; + var $4=$1; + var $5=HEAP32[((_operators)>>2)]; + var $6=$4; + var $7=$5; + var $8=((($6)-($7))|0); + var $9=((((($8)|0))/(24))&-1); + var $10=((($9)+(1))|0); + var $11=(($e)|0); + HEAP32[(($11)>>2)]=$10; + var $12=(($e+8)|0); + HEAP32[(($12)>>2)]=0; + var $13=(($e+12)|0); + HEAP32[(($13)>>2)]=0; + var $14=(($e+16)|0); + HEAP32[(($14)>>2)]=0; + var $15=(($e+20)|0); + var $16=$15; + var $17=$ctx; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($16)>>2)]=HEAP32[(($17)>>2)];HEAP32[((($16)+(4))>>2)]=HEAP32[((($17)+(4))>>2)]; + var $18=(($e+4)|0); + HEAP32[(($18)>>2)]=0; + var $19=$agg_result; + var $20=$e; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($19)>>2)]=HEAP32[(($20)>>2)];HEAP32[((($19)+(4))>>2)]=HEAP32[((($20)+(4))>>2)];HEAP32[((($19)+(8))>>2)]=HEAP32[((($20)+(8))>>2)];HEAP32[((($19)+(12))>>2)]=HEAP32[((($20)+(12))>>2)];HEAP32[((($19)+(16))>>2)]=HEAP32[((($20)+(16))>>2)];HEAP32[((($19)+(20))>>2)]=HEAP32[((($20)+(20))>>2)];HEAP32[((($19)+(24))>>2)]=HEAP32[((($20)+(24))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _syblock($agg_result, $ctx_0, $ctx_1, $v) { + var __stackBase__ = STACKTOP; STACKTOP += 36; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $ctx=__stackBase__; + var $1; + var $e=(__stackBase__)+(8); + var $2=(($ctx)|0); + HEAP32[(($2)>>2)]=$ctx_0; + var $3=(($ctx+4)|0); + HEAP32[(($3)>>2)]=$ctx_1; + $1=$v; + var $4=(($e)|0); + HEAP32[(($4)>>2)]=0; + var $5=(($e+8)|0); + HEAP32[(($5)>>2)]=0; + var $6=$1; + var $7=$6; + var $8=(($e+12)|0); + HEAP32[(($8)>>2)]=$7; + var $9=$1; + var $10=(($e+16)|0); + HEAP32[(($10)>>2)]=$9; + var $11=(($e+20)|0); + var $12=$11; + var $13=$ctx; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($12)>>2)]=HEAP32[(($13)>>2)];HEAP32[((($12)+(4))>>2)]=HEAP32[((($13)+(4))>>2)]; + var $14=(($e+4)|0); + HEAP32[(($14)>>2)]=0; + var $15=$agg_result; + var $16=$e; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($15)>>2)]=HEAP32[(($16)>>2)];HEAP32[((($15)+(4))>>2)]=HEAP32[((($16)+(4))>>2)];HEAP32[((($15)+(8))>>2)]=HEAP32[((($16)+(8))>>2)];HEAP32[((($15)+(12))>>2)]=HEAP32[((($16)+(12))>>2)];HEAP32[((($15)+(16))>>2)]=HEAP32[((($16)+(16))>>2)];HEAP32[((($15)+(20))>>2)]=HEAP32[((($16)+(20))>>2)];HEAP32[((($15)+(24))>>2)]=HEAP32[((($16)+(24))>>2)]; + STACKTOP = __stackBase__; + return; +} + + +function _parser_const_float_0($parser) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$parser; + var $2=$1; + var $3=(($2+80)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $7=$1; + var $8=_parser_const_float($7, 0); + var $9=$1; + var $10=(($9+80)|0); + HEAP32[(($10)>>2)]=$8; + __label__ = 4; break; + case 4: + var $12=$1; + var $13=(($12+80)|0); + var $14=HEAP32[(($13)>>2)]; + ; + return $14; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_const_vector_f($parser, $x, $y, $z) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $2; + var $3; + var $4; + var $v=__stackBase__; + $1=$parser; + $2=$x; + $3=$y; + $4=$z; + var $5=$2; + var $6=(($v)|0); + HEAPF32[(($6)>>2)]=$5; + var $7=$3; + var $8=(($v+4)|0); + HEAPF32[(($8)>>2)]=$7; + var $9=$4; + var $10=(($v+8)|0); + HEAPF32[(($10)>>2)]=$9; + var $11=$1; + var $12=(($v)|0); + var $13=HEAPF32[(($12)>>2)]; + var $14=(($v+4)|0); + var $15=HEAPF32[(($14)>>2)]; + var $16=(($v+8)|0); + var $17=HEAPF32[(($16)>>2)]; + var $18=_parser_const_vector($11, $13, $15, $17); + STACKTOP = __stackBase__; + return $18; +} + + +function _parser_const_vector_0($parser) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$parser; + var $2=$1; + var $3=(($2+84)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $7=$1; + var $8=_parser_const_vector_f($7, 0, 0, 0); + var $9=$1; + var $10=(($9+84)|0); + HEAP32[(($10)>>2)]=$8; + __label__ = 4; break; + case 4: + var $12=$1; + var $13=(($12+84)|0); + var $14=HEAP32[(($13)>>2)]; + ; + return $14; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_close_call($parser, $sy) { + var __stackBase__ = STACKTOP; STACKTOP += 28; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $fun; + var $call; + var $fid; + var $paramcount; + var $params; + var $4=__stackBase__; + var $fval; + var $fewmany; + $2=$parser; + $3=$sy; + var $5=$3; + var $6=(($5+16)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=((($7)-(1))|0); + HEAP32[(($6)>>2)]=$8; + var $9=$3; + var $10=(($9+16)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=$3; + var $13=(($12+12)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11)*(28))|0); + var $16=(($15+8)|0); + var $17=HEAP32[(($16)>>2)]; + $fid=$17; + var $18=$3; + var $19=(($18+4)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($20)>>>0) < 1; + if ($21) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $23=$3; + var $24=(($23+4)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=$fid; + var $27=(($25)>>>0) <= (($26)>>>0); + if ($27) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $29=$2; + _parseerror($29, ((STRING_TABLE.__str94666)|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)); + $1=0; + __label__ = 40; break; + case 5: + var $31=$fid; + var $32=$3; + var $33=(($32)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=(($34+($31)*(28))|0); + var $36=(($35+12)|0); + var $37=HEAP32[(($36)>>2)]; + $fun=$37; + var $38=$3; + var $39=(($38+16)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$3; + var $42=(($41+12)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($43+($40)*(28))|0); + var $45=(($44+20)|0); + var $46=$fun; + var $47=(($45)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($45+4)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=_ast_call_new($48, $50, $46); + $call=$51; + var $52=$call; + var $53=(($52)|0)!=0; + if ($53) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $55=$2; + _parseerror($55, ((STRING_TABLE.__str61633)|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)); + $1=0; + __label__ = 40; break; + case 7: + var $57=$fid; + var $58=((($57)+(1))|0); + var $59=$3; + var $60=(($59+4)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($58)|0)==(($61)|0); + if ($62) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + $paramcount=0; + __label__ = 20; break; + case 9: + var $65=$fid; + var $66=((($65)+(2))|0); + var $67=$3; + var $68=(($67+4)|0); + var $69=HEAP32[(($68)>>2)]; + var $70=(($66)|0)==(($69)|0); + if ($70) { __label__ = 10; break; } else { __label__ = 18; break; } + case 10: + var $72=$3; + var $73=(($72+4)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=((($74)-(1))|0); + HEAP32[(($73)>>2)]=$75; + var $76=$3; + var $77=(($76+4)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=$3; + var $80=(($79)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=(($81+($78)*(28))|0); + var $83=(($82+16)|0); + var $84=HEAP32[(($83)>>2)]; + $params=$84; + var $85=$params; + var $86=(($85)|0)!=0; + if ($86) { __label__ = 14; break; } else { __label__ = 11; break; } + case 11: + $paramcount=1; + var $88=$call; + var $89=$3; + var $90=(($89+4)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=$3; + var $93=(($92)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=(($94+($91)*(28))|0); + var $96=(($95+12)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=_ast_call_params_add($88, $97); + if ($98) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + var $100=$3; + var $101=(($100+4)|0); + var $102=HEAP32[(($101)>>2)]; + var $103=$3; + var $104=(($103)|0); + var $105=HEAP32[(($104)>>2)]; + var $106=(($105+($102)*(28))|0); + var $107=(($106+12)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=$108; + var $110=$109; + var $111=(($110+8)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=$3; + var $114=(($113+4)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=$3; + var $117=(($116)|0); + var $118=HEAP32[(($117)>>2)]; + var $119=(($118+($115)*(28))|0); + var $120=(($119+12)|0); + var $121=HEAP32[(($120)>>2)]; + var $122=$121; + FUNCTION_TABLE[$112]($122); + var $123=$2; + _parseerror($123, ((STRING_TABLE.__str61633)|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)); + $1=0; + __label__ = 40; break; + case 13: + __label__ = 15; break; + case 14: + var $126=$params; + var $127=(($126+72)|0); + var $128=HEAP32[(($127)>>2)]; + $paramcount=$128; + var $129=$params; + var $130=(($129+68)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=$call; + var $133=(($132+60)|0); + HEAP32[(($133)>>2)]=$131; + var $134=$params; + var $135=(($134+72)|0); + var $136=HEAP32[(($135)>>2)]; + var $137=$call; + var $138=(($137+64)|0); + HEAP32[(($138)>>2)]=$136; + var $139=$params; + var $140=(($139+76)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=$call; + var $143=(($142+68)|0); + HEAP32[(($143)>>2)]=$141; + var $144=$params; + var $145=(($144+68)|0); + HEAP32[(($145)>>2)]=0; + var $146=$params; + var $147=(($146+72)|0); + HEAP32[(($147)>>2)]=0; + var $148=$params; + var $149=(($148+76)|0); + HEAP32[(($149)>>2)]=0; + var $150=$params; + var $151=$150; + var $152=$151; + var $153=(($152+8)|0); + var $154=HEAP32[(($153)>>2)]; + var $155=$params; + var $156=$155; + FUNCTION_TABLE[$154]($156); + __label__ = 15; break; + case 15: + var $158=$call; + var $159=_ast_call_check_types($158); + if ($159) { __label__ = 17; break; } else { __label__ = 16; break; } + case 16: + var $161=$2; + var $162=(($161+116)|0); + var $163=HEAP32[(($162)>>2)]; + var $164=((($163)+(1))|0); + HEAP32[(($162)>>2)]=$164; + __label__ = 17; break; + case 17: + __label__ = 19; break; + case 18: + var $167=$2; + _parseerror($167, ((STRING_TABLE.__str95667)|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)); + $1=0; + __label__ = 40; break; + case 19: + __label__ = 20; break; + case 20: + var $170=$fid; + var $171=$3; + var $172=(($171)|0); + var $173=HEAP32[(($172)>>2)]; + var $174=(($173+($170)*(28))|0); + var $175=$call; + var $176=(($175)|0); + var $177=(($176)|0); + var $178=(($177)|0); + var $179=$call; + var $180=$179; + var $181=(($178)|0); + var $182=HEAP32[(($181)>>2)]; + var $183=(($178+4)|0); + var $184=HEAP32[(($183)>>2)]; + _syexp($4, $182, $184, $180); + var $185=$174; + var $186=$4; + assert(28 % 1 === 0, 'memcpy given ' + 28 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($185)>>2)]=HEAP32[(($186)>>2)];HEAP32[((($185)+(4))>>2)]=HEAP32[((($186)+(4))>>2)];HEAP32[((($185)+(8))>>2)]=HEAP32[((($186)+(8))>>2)];HEAP32[((($185)+(12))>>2)]=HEAP32[((($186)+(12))>>2)];HEAP32[((($185)+(16))>>2)]=HEAP32[((($186)+(16))>>2)];HEAP32[((($185)+(20))>>2)]=HEAP32[((($186)+(20))>>2)];HEAP32[((($185)+(24))>>2)]=HEAP32[((($186)+(24))>>2)]; + var $187=$fun; + var $188=$187; + var $189=(($188+24)|0); + var $190=HEAP32[(($189)>>2)]; + var $191=(($190)|0)!=6; + if ($191) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $193=$2; + var $194=$fun; + var $195=$194; + var $196=(($195+24)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=((_type_name+($197<<2))|0); + var $199=HEAP32[(($198)>>2)]; + _parseerror($193, ((STRING_TABLE.__str96668)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$199,tempInt)); + $1=0; + __label__ = 40; break; + case 22: + var $201=$fun; + var $202=$201; + var $203=(($202+28)|0); + var $204=HEAP32[(($203)>>2)]; + var $205=(($204)|0)!=0; + if ($205) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $207=$2; + _parseerror($207, ((STRING_TABLE.__str97669)|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)); + $1=0; + __label__ = 40; break; + case 24: + var $209=$fun; + var $210=$209; + var $211=(($210+36)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=$paramcount; + var $214=(($212)|0)!=(($213)|0); + if ($214) { __label__ = 25; break; } else { __label__ = 38; break; } + case 25: + var $216=$fun; + var $217=$216; + var $218=(($217+44)|0); + var $219=HEAP8[($218)]; + var $220=(($219) & 1); + if ($220) { __label__ = 26; break; } else { __label__ = 27; break; } + case 26: + var $222=$fun; + var $223=$222; + var $224=(($223+36)|0); + var $225=HEAP32[(($224)>>2)]; + var $226=$paramcount; + var $227=(($225)>>>0) < (($226)>>>0); + if ($227) { __label__ = 38; break; } else { __label__ = 27; break; } + case 27: + var $229=$fun; + var $230=$229; + var $231=(($230+36)|0); + var $232=HEAP32[(($231)>>2)]; + var $233=$paramcount; + var $234=(($232)>>>0) > (($233)>>>0); + var $235=$234 ? (((STRING_TABLE.__str98670)|0)) : (((STRING_TABLE.__str99671)|0)); + $fewmany=$235; + var $236=$fun; + var $237=$236; + var $238=(($237+12)|0); + var $239=HEAP32[(($238)>>2)]; + var $240=(($239)|0)==2; + if ($240) { __label__ = 28; break; } else { __label__ = 29; break; } + case 28: + var $242=$fun; + var $243=$242; + var $246 = $243;__label__ = 30; break; + case 29: + var $246 = 0;__label__ = 30; break; + case 30: + var $246; + $fval=$246; + var $247=HEAP32[((_opts_standard)>>2)]; + var $248=(($247)|0)==3; + if ($248) { __label__ = 31; break; } else { __label__ = 35; break; } + case 31: + var $250=$fval; + var $251=(($250)|0)!=0; + if ($251) { __label__ = 32; break; } else { __label__ = 33; break; } + case 32: + var $253=$2; + var $254=$fewmany; + var $255=$fval; + var $256=(($255+56)|0); + var $257=HEAP32[(($256)>>2)]; + var $258=$fun; + var $259=$258; + var $260=(($259+36)|0); + var $261=HEAP32[(($260)>>2)]; + var $262=$paramcount; + var $263=$fval; + var $264=(($263+56)|0); + var $265=HEAP32[(($264)>>2)]; + var $266=$fun; + var $267=$266; + var $268=(($267)|0); + var $269=(($268)|0); + var $270=HEAP32[(($269)>>2)]; + var $271=$fun; + var $272=$271; + var $273=(($272)|0); + var $274=(($273+4)|0); + var $275=HEAP32[(($274)>>2)]; + _parseerror($253, ((STRING_TABLE.__str100672)|0), (tempInt=STACKTOP,STACKTOP += 28,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$254,HEAP32[(((tempInt)+(4))>>2)]=$257,HEAP32[(((tempInt)+(8))>>2)]=$261,HEAP32[(((tempInt)+(12))>>2)]=$262,HEAP32[(((tempInt)+(16))>>2)]=$265,HEAP32[(((tempInt)+(20))>>2)]=$270,HEAP32[(((tempInt)+(24))>>2)]=$275,tempInt)); + __label__ = 34; break; + case 33: + var $277=$2; + var $278=$fewmany; + var $279=$fval; + var $280=(($279+56)|0); + var $281=HEAP32[(($280)>>2)]; + var $282=$fun; + var $283=$282; + var $284=(($283+36)|0); + var $285=HEAP32[(($284)>>2)]; + var $286=$paramcount; + var $287=$fval; + var $288=(($287+56)|0); + var $289=HEAP32[(($288)>>2)]; + var $290=$fun; + var $291=$290; + var $292=(($291)|0); + var $293=(($292)|0); + var $294=HEAP32[(($293)>>2)]; + var $295=$fun; + var $296=$295; + var $297=(($296)|0); + var $298=(($297+4)|0); + var $299=HEAP32[(($298)>>2)]; + _parseerror($277, ((STRING_TABLE.__str101673)|0), (tempInt=STACKTOP,STACKTOP += 28,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$278,HEAP32[(((tempInt)+(4))>>2)]=$281,HEAP32[(((tempInt)+(8))>>2)]=$285,HEAP32[(((tempInt)+(12))>>2)]=$286,HEAP32[(((tempInt)+(16))>>2)]=$289,HEAP32[(((tempInt)+(20))>>2)]=$294,HEAP32[(((tempInt)+(24))>>2)]=$299,tempInt)); + __label__ = 34; break; + case 34: + $1=0; + __label__ = 40; break; + case 35: + var $302=$fval; + var $303=(($302)|0)!=0; + if ($303) { __label__ = 36; break; } else { __label__ = 37; break; } + case 36: + var $305=$2; + var $306=$fewmany; + var $307=$fval; + var $308=(($307+56)|0); + var $309=HEAP32[(($308)>>2)]; + var $310=$fun; + var $311=$310; + var $312=(($311+36)|0); + var $313=HEAP32[(($312)>>2)]; + var $314=$paramcount; + var $315=$fval; + var $316=(($315+56)|0); + var $317=HEAP32[(($316)>>2)]; + var $318=$fun; + var $319=$318; + var $320=(($319)|0); + var $321=(($320)|0); + var $322=HEAP32[(($321)>>2)]; + var $323=$fun; + var $324=$323; + var $325=(($324)|0); + var $326=(($325+4)|0); + var $327=HEAP32[(($326)>>2)]; + var $328=_parsewarning($305, 7, ((STRING_TABLE.__str100672)|0), (tempInt=STACKTOP,STACKTOP += 28,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$306,HEAP32[(((tempInt)+(4))>>2)]=$309,HEAP32[(((tempInt)+(8))>>2)]=$313,HEAP32[(((tempInt)+(12))>>2)]=$314,HEAP32[(((tempInt)+(16))>>2)]=$317,HEAP32[(((tempInt)+(20))>>2)]=$322,HEAP32[(((tempInt)+(24))>>2)]=$327,tempInt)); + var $329=$328 ^ 1; + $1=$329; + __label__ = 40; break; + case 37: + var $331=$2; + var $332=$fewmany; + var $333=$fval; + var $334=(($333+56)|0); + var $335=HEAP32[(($334)>>2)]; + var $336=$fun; + var $337=$336; + var $338=(($337+36)|0); + var $339=HEAP32[(($338)>>2)]; + var $340=$paramcount; + var $341=$fval; + var $342=(($341+56)|0); + var $343=HEAP32[(($342)>>2)]; + var $344=$fun; + var $345=$344; + var $346=(($345)|0); + var $347=(($346)|0); + var $348=HEAP32[(($347)>>2)]; + var $349=$fun; + var $350=$349; + var $351=(($350)|0); + var $352=(($351+4)|0); + var $353=HEAP32[(($352)>>2)]; + var $354=_parsewarning($331, 7, ((STRING_TABLE.__str101673)|0), (tempInt=STACKTOP,STACKTOP += 28,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$332,HEAP32[(((tempInt)+(4))>>2)]=$335,HEAP32[(((tempInt)+(8))>>2)]=$339,HEAP32[(((tempInt)+(12))>>2)]=$340,HEAP32[(((tempInt)+(16))>>2)]=$343,HEAP32[(((tempInt)+(20))>>2)]=$348,HEAP32[(((tempInt)+(24))>>2)]=$353,tempInt)); + var $355=$354 ^ 1; + $1=$355; + __label__ = 40; break; + case 38: + __label__ = 39; break; + case 39: + $1=1; + __label__ = 40; break; + case 40: + var $359=$1; + STACKTOP = __stackBase__; + return $359; + default: assert(0, "bad label: " + __label__); + } +} +_parser_close_call["X"]=1; + +function _parse_block_into($parser, $block, $warnreturn) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $oldblocklocal; + var $retval; + var $expr=__stackBase__; + $1=$parser; + $2=$block; + var $4=(($warnreturn)&1); + $3=$4; + $retval=1; + var $5=$1; + var $6=(($5+112)|0); + var $7=HEAP32[(($6)>>2)]; + $oldblocklocal=$7; + var $8=$1; + var $9=(($8+104)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=$1; + var $12=(($11+112)|0); + HEAP32[(($12)>>2)]=$10; + var $13=$1; + var $14=_parser_next($13); + if ($14) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $16=$1; + _parseerror($16, ((STRING_TABLE.__str126698)|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)); + __label__ = 29; break; + case 4: + __label__ = 5; break; + case 5: + var $19=$1; + var $20=(($19+4)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=(($21)|0)!=141; + if ($22) { __label__ = 6; break; } else { var $29 = 0;__label__ = 7; break; } + case 6: + var $24=$1; + var $25=(($24+4)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=(($26)|0) < 142; + var $29 = $27;__label__ = 7; break; + case 7: + var $29; + if ($29) { __label__ = 8; break; } else { __label__ = 17; break; } + case 8: + var $31=$1; + var $32=(($31+4)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=(($33)|0)==125; + if ($34) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + __label__ = 17; break; + case 10: + var $37=$1; + var $38=$2; + var $39=_parse_statement($37, $38, $expr); + if ($39) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + $2=0; + __label__ = 29; break; + case 12: + var $42=HEAP32[(($expr)>>2)]; + var $43=(($42)|0)!=0; + if ($43) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + __label__ = 5; break; + case 14: + var $46=$2; + var $47=HEAP32[(($expr)>>2)]; + var $48=_ast_block_exprs_add($46, $47); + if ($48) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $50=HEAP32[(($expr)>>2)]; + var $51=$50; + var $52=$51; + var $53=(($52+8)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=HEAP32[(($expr)>>2)]; + var $56=$55; + FUNCTION_TABLE[$54]($56); + $2=0; + __label__ = 29; break; + case 16: + __label__ = 5; break; + case 17: + var $59=$1; + var $60=(($59+4)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61)|0)!=125; + if ($62) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + $2=0; + __label__ = 28; break; + case 19: + var $65=$3; + var $66=(($65) & 1); + if ($66) { __label__ = 20; break; } else { __label__ = 27; break; } + case 20: + var $68=$1; + var $69=(($68+96)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($70+20)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=(($72)|0); + var $74=(($73+28)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + var $77=(($76+24)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($78)|0)!=0; + if ($79) { __label__ = 21; break; } else { __label__ = 27; break; } + case 21: + var $81=$2; + var $82=(($81+72)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=(($83)|0)!=0; + if ($84) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $86=$2; + var $87=(($86+72)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=((($88)-(1))|0); + var $90=$2; + var $91=(($90+68)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($92+($89<<2))|0); + var $94=HEAP32[(($93)>>2)]; + var $95=$94; + var $96=(($95+12)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=(($97)|0)==14; + if ($98) { __label__ = 26; break; } else { __label__ = 23; break; } + case 23: + var $100=$1; + var $101=_parsewarning($100, 6, ((STRING_TABLE.__str127699)|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)); + if ($101) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + $2=0; + __label__ = 29; break; + case 25: + __label__ = 26; break; + case 26: + __label__ = 27; break; + case 27: + var $106=$1; + var $107=_parser_next($106); + __label__ = 28; break; + case 28: + __label__ = 29; break; + case 29: + __label__ = 30; break; + case 30: + var $111=$1; + var $112=(($111+104)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$1; + var $115=(($114+112)|0); + var $116=HEAP32[(($115)>>2)]; + var $117=(($113)>>>0) > (($116)>>>0); + if ($117) { __label__ = 31; break; } else { __label__ = 34; break; } + case 31: + var $119=$retval; + var $120=(($119) & 1); + if ($120) { __label__ = 32; break; } else { var $125 = 0;__label__ = 33; break; } + case 32: + var $122=$1; + var $123=_parser_pop_local($122); + var $125 = $123;__label__ = 33; break; + case 33: + var $125; + var $126=(($125)&1); + $retval=$126; + __label__ = 30; break; + case 34: + var $128=$oldblocklocal; + var $129=$1; + var $130=(($129+112)|0); + HEAP32[(($130)>>2)]=$128; + var $131=$2; + var $132=(($131)|0)!=0; + var $133=$132 ^ 1; + var $134=$133 ^ 1; + STACKTOP = __stackBase__; + return $134; + default: assert(0, "bad label: " + __label__); + } +} +_parse_block_into["X"]=1; + +function _parser_pop_local($parser) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $ve; + $2=$parser; + var $3=$2; + var $4=(($3+104)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=((($5)-(1))|0); + HEAP32[(($4)>>2)]=$6; + var $7=$2; + var $8=(($7+104)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=$2; + var $11=(($10+100)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12+($9<<3))|0); + $ve=$13; + var $14=$ve; + var $15=(($14+4)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=$16; + var $18=(($17+12)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($19)|0)==2; + if ($20) { __label__ = 3; break; } else { __label__ = 7; break; } + case 3: + var $22=$ve; + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$24; + var $26=(($25+76)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27)|0)!=0; + if ($28) { __label__ = 7; break; } else { __label__ = 4; break; } + case 4: + var $30=$2; + var $31=$ve; + var $32=(($31)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=_parsewarning($30, 1, ((STRING_TABLE.__str125697)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$33,tempInt)); + if ($34) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + $1=0; + __label__ = 8; break; + case 6: + __label__ = 7; break; + case 7: + var $38=$2; + var $39=(($38+104)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=$2; + var $42=(($41+100)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=(($43+($40<<3))|0); + var $45=(($44)|0); + var $46=HEAP32[(($45)>>2)]; + _util_memory_d($46, 1842, ((STRING_TABLE.__str572)|0)); + $1=1; + __label__ = 8; break; + case 8: + var $48=$1; + STACKTOP = __stackBase__; + return $48; + default: assert(0, "bad label: " + __label__); + } +} +_parser_pop_local["X"]=1; + +function _parse_statement($parser, $block, $out) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $exp; + var $ret; + var $expected; + var $inner; + var $exp1; + $2=$parser; + $3=$block; + $4=$out; + var $5=$2; + var $6=(($5+4)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7)|0)==130; + if ($8) { __label__ = 3; break; } else { __label__ = 12; break; } + case 3: + var $10=$3; + var $11=(($10)|0)!=0; + if ($11) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $13=$2; + _parseerror($13, ((STRING_TABLE.__str128700)|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)); + $1=0; + __label__ = 72; break; + case 5: + var $15=HEAP32[((_opts_standard)>>2)]; + var $16=(($15)|0)==0; + if ($16) { __label__ = 6; break; } else { __label__ = 9; break; } + case 6: + var $18=$2; + var $19=_parsewarning($18, 4, ((STRING_TABLE.__str129701)|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)); + if ($19) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + $1=0; + __label__ = 72; break; + case 8: + __label__ = 9; break; + case 9: + var $23=$2; + var $24=$3; + var $25=_parse_variable($23, $24); + if ($25) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 72; break; + case 11: + var $28=$4; + HEAP32[(($28)>>2)]=0; + $1=1; + __label__ = 72; break; + case 12: + var $30=$2; + var $31=(($30+4)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=(($32)|0)==132; + if ($33) { __label__ = 13; break; } else { __label__ = 59; break; } + case 13: + var $35=$2; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37+292)|0); + var $39=(($38+4)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=_strcmp($40, ((STRING_TABLE.__str130702)|0)); + var $42=(($41)|0)!=0; + if ($42) { __label__ = 21; break; } else { __label__ = 14; break; } + case 14: + var $44=$3; + var $45=(($44)|0)!=0; + if ($45) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + var $47=$2; + _parseerror($47, ((STRING_TABLE.__str131703)|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)); + $1=0; + __label__ = 72; break; + case 16: + var $49=$2; + var $50=_parser_next($49); + if ($50) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $52=$2; + _parseerror($52, ((STRING_TABLE.__str132704)|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)); + $1=0; + __label__ = 72; break; + case 18: + var $54=$2; + var $55=$3; + var $56=_parse_variable($54, $55); + if ($56) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + $1=0; + __label__ = 72; break; + case 20: + var $59=$4; + HEAP32[(($59)>>2)]=0; + $1=1; + __label__ = 72; break; + case 21: + var $61=$2; + var $62=(($61)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=(($63+292)|0); + var $65=(($64+4)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=_strcmp($66, ((STRING_TABLE.__str133705)|0)); + var $68=(($67)|0)!=0; + if ($68) { __label__ = 41; break; } else { __label__ = 22; break; } + case 22: + $exp=0; + $ret=0; + var $70=$2; + var $71=(($70+96)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=(($72+20)|0); + var $74=HEAP32[(($73)>>2)]; + $expected=$74; + var $75=$2; + var $76=_parser_next($75); + if ($76) { __label__ = 24; break; } else { __label__ = 23; break; } + case 23: + var $78=$2; + _parseerror($78, ((STRING_TABLE.__str134706)|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)); + $1=0; + __label__ = 72; break; + case 24: + var $80=$2; + var $81=(($80+4)|0); + var $82=HEAP32[(($81)>>2)]; + var $83=(($82)|0)!=59; + if ($83) { __label__ = 25; break; } else { __label__ = 32; break; } + case 25: + var $85=$2; + var $86=_parse_expression($85, 0); + $exp=$86; + var $87=$exp; + var $88=(($87)|0)!=0; + if ($88) { __label__ = 27; break; } else { __label__ = 26; break; } + case 26: + $1=0; + __label__ = 72; break; + case 27: + var $91=$exp; + var $92=$91; + var $93=(($92+24)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=$expected; + var $96=(($95)|0); + var $97=(($96+28)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=$98; + var $100=(($99+24)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=(($94)|0)!=(($101)|0); + if ($102) { __label__ = 28; break; } else { __label__ = 29; break; } + case 28: + var $104=$2; + _parseerror($104, ((STRING_TABLE.__str135707)|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)); + __label__ = 29; break; + case 29: + var $106=$exp; + var $107=$106; + var $108=(($107)|0); + var $109=(($108)|0); + var $110=$exp; + var $111=(($109)|0); + var $112=HEAP32[(($111)>>2)]; + var $113=(($109+4)|0); + var $114=HEAP32[(($113)>>2)]; + var $115=_ast_return_new($112, $114, $110); + $ret=$115; + var $116=$ret; + var $117=(($116)|0)!=0; + if ($117) { __label__ = 31; break; } else { __label__ = 30; break; } + case 30: + var $119=$exp; + var $120=$119; + var $121=$120; + var $122=(($121+8)|0); + var $123=HEAP32[(($122)>>2)]; + var $124=$exp; + var $125=$124; + FUNCTION_TABLE[$123]($125); + $1=0; + __label__ = 72; break; + case 31: + __label__ = 40; break; + case 32: + var $128=$2; + var $129=_parser_next($128); + if ($129) { __label__ = 34; break; } else { __label__ = 33; break; } + case 33: + var $131=$2; + _parseerror($131, ((STRING_TABLE.__str4576)|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)); + __label__ = 34; break; + case 34: + var $133=$expected; + var $134=(($133)|0); + var $135=(($134+28)|0); + var $136=HEAP32[(($135)>>2)]; + var $137=$136; + var $138=(($137+24)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=(($139)|0)!=0; + if ($140) { __label__ = 35; break; } else { __label__ = 39; break; } + case 35: + var $142=HEAP32[((_opts_standard)>>2)]; + var $143=(($142)|0)!=3; + if ($143) { __label__ = 36; break; } else { __label__ = 37; break; } + case 36: + var $145=$2; + var $146=_parsewarning($145, 6, ((STRING_TABLE.__str136708)|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)); + var $147=$146 ^ 1; + var $148=(($147)&1); + __label__ = 38; break; + case 37: + var $150=$2; + _parseerror($150, ((STRING_TABLE.__str136708)|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)); + __label__ = 38; break; + case 38: + __label__ = 39; break; + case 39: + var $153=$2; + var $154=(($153)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=(($155+292)|0); + var $157=(($156+28)|0); + var $158=(($157)|0); + var $159=HEAP32[(($158)>>2)]; + var $160=(($157+4)|0); + var $161=HEAP32[(($160)>>2)]; + var $162=_ast_return_new($159, $161, 0); + $ret=$162; + __label__ = 40; break; + case 40: + var $164=$ret; + var $165=$164; + var $166=$4; + HEAP32[(($166)>>2)]=$165; + $1=1; + __label__ = 72; break; + case 41: + var $168=$2; + var $169=(($168)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=(($170+292)|0); + var $172=(($171+4)|0); + var $173=HEAP32[(($172)>>2)]; + var $174=_strcmp($173, ((STRING_TABLE.__str137709)|0)); + var $175=(($174)|0)!=0; + if ($175) { __label__ = 43; break; } else { __label__ = 42; break; } + case 42: + var $177=$2; + var $178=$3; + var $179=$4; + var $180=_parse_if($177, $178, $179); + $1=$180; + __label__ = 72; break; + case 43: + var $182=$2; + var $183=(($182)|0); + var $184=HEAP32[(($183)>>2)]; + var $185=(($184+292)|0); + var $186=(($185+4)|0); + var $187=HEAP32[(($186)>>2)]; + var $188=_strcmp($187, ((STRING_TABLE.__str138710)|0)); + var $189=(($188)|0)!=0; + if ($189) { __label__ = 45; break; } else { __label__ = 44; break; } + case 44: + var $191=$2; + var $192=$3; + var $193=$4; + var $194=_parse_while($191, $192, $193); + $1=$194; + __label__ = 72; break; + case 45: + var $196=$2; + var $197=(($196)|0); + var $198=HEAP32[(($197)>>2)]; + var $199=(($198+292)|0); + var $200=(($199+4)|0); + var $201=HEAP32[(($200)>>2)]; + var $202=_strcmp($201, ((STRING_TABLE.__str139711)|0)); + var $203=(($202)|0)!=0; + if ($203) { __label__ = 47; break; } else { __label__ = 46; break; } + case 46: + var $205=$2; + var $206=$3; + var $207=$4; + var $208=_parse_dowhile($205, $206, $207); + $1=$208; + __label__ = 72; break; + case 47: + var $210=$2; + var $211=(($210)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=(($212+292)|0); + var $214=(($213+4)|0); + var $215=HEAP32[(($214)>>2)]; + var $216=_strcmp($215, ((STRING_TABLE.__str140712)|0)); + var $217=(($216)|0)!=0; + if ($217) { __label__ = 53; break; } else { __label__ = 48; break; } + case 48: + var $219=HEAP32[((_opts_standard)>>2)]; + var $220=(($219)|0)==0; + if ($220) { __label__ = 49; break; } else { __label__ = 52; break; } + case 49: + var $222=$2; + var $223=_parsewarning($222, 4, ((STRING_TABLE.__str141713)|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)); + if ($223) { __label__ = 50; break; } else { __label__ = 51; break; } + case 50: + $1=0; + __label__ = 72; break; + case 51: + __label__ = 52; break; + case 52: + var $227=$2; + var $228=$3; + var $229=$4; + var $230=_parse_for($227, $228, $229); + $1=$230; + __label__ = 72; break; + case 53: + __label__ = 54; break; + case 54: + __label__ = 55; break; + case 55: + __label__ = 56; break; + case 56: + __label__ = 57; break; + case 57: + __label__ = 58; break; + case 58: + var $237=$2; + _parseerror($237, ((STRING_TABLE.__str142714)|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)); + $1=0; + __label__ = 72; break; + case 59: + var $239=$2; + var $240=(($239+4)|0); + var $241=HEAP32[(($240)>>2)]; + var $242=(($241)|0)==123; + if ($242) { __label__ = 60; break; } else { __label__ = 63; break; } + case 60: + var $244=$2; + var $245=_parse_block($244, 0); + $inner=$245; + var $246=$inner; + var $247=(($246)|0)!=0; + if ($247) { __label__ = 62; break; } else { __label__ = 61; break; } + case 61: + $1=0; + __label__ = 72; break; + case 62: + var $250=$inner; + var $251=$250; + var $252=$4; + HEAP32[(($252)>>2)]=$251; + $1=1; + __label__ = 72; break; + case 63: + var $254=$2; + var $255=_parse_expression($254, 0); + $exp1=$255; + var $256=$exp1; + var $257=(($256)|0)!=0; + if ($257) { __label__ = 65; break; } else { __label__ = 64; break; } + case 64: + $1=0; + __label__ = 72; break; + case 65: + var $260=$exp1; + var $261=$4; + HEAP32[(($261)>>2)]=$260; + var $262=$exp1; + var $263=$262; + var $264=(($263+12)|0); + var $265=HEAP32[(($264)>>2)]; + var $266=(($265)|0)==6; + if ($266) { __label__ = 71; break; } else { __label__ = 66; break; } + case 66: + var $268=$exp1; + var $269=$268; + var $270=(($269+12)|0); + var $271=HEAP32[(($270)>>2)]; + var $272=(($271)|0)==12; + if ($272) { __label__ = 71; break; } else { __label__ = 67; break; } + case 67: + var $274=$exp1; + var $275=$274; + var $276=(($275+12)|0); + var $277=HEAP32[(($276)>>2)]; + var $278=(($277)|0)==7; + if ($278) { __label__ = 71; break; } else { __label__ = 68; break; } + case 68: + var $280=$exp1; + var $281=$280; + var $282=(($281)|0); + var $283=(($282)|0); + var $284=HEAP32[(($283)>>2)]; + var $285=(($282+4)|0); + var $286=HEAP32[(($285)>>2)]; + var $287=_genwarning($284, $286, 14, ((STRING_TABLE.__str143715)|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)); + if ($287) { __label__ = 69; break; } else { __label__ = 70; break; } + case 69: + $1=0; + __label__ = 72; break; + case 70: + __label__ = 71; break; + case 71: + $1=1; + __label__ = 72; break; + case 72: + var $292=$1; + STACKTOP = __stackBase__; + return $292; + default: assert(0, "bad label: " + __label__); + } +} +_parse_statement["X"]=1; + +function _parse_expression($parser, $stopatcomma) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $e; + $2=$parser; + var $4=(($stopatcomma)&1); + $3=$4; + var $5=$2; + var $6=$3; + var $7=(($6) & 1); + var $8=_parse_expression_leave($5, $7); + $e=$8; + var $9=$e; + var $10=(($9)|0)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $13=$2; + var $14=_parser_next($13); + if ($14) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $16=$e; + var $17=$16; + var $18=$17; + var $19=(($18+8)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=$e; + var $22=$21; + FUNCTION_TABLE[$20]($22); + $1=0; + __label__ = 7; break; + case 6: + var $24=$e; + $1=$24; + __label__ = 7; break; + case 7: + var $26=$1; + ; + return $26; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parse_if($parser, $block, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $ifthen; + var $cond; + var $ontrue; + var $onfalse; + var $ctx=__stackBase__; + $2=$parser; + $3=$block; + $4=$out; + $onfalse=0; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=$ctx; + var $11=$9; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=$2; + var $13=_parser_next($12); + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$2; + var $16=(($15+4)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0)!=40; + if ($18) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $20=$2; + _parseerror($20, ((STRING_TABLE.__str159)|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)); + $1=0; + __label__ = 22; break; + case 5: + var $22=$2; + var $23=_parser_next($22); + if ($23) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $25=$2; + _parseerror($25, ((STRING_TABLE.__str160)|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)); + $1=0; + __label__ = 22; break; + case 7: + var $27=$2; + var $28=_parse_expression_leave($27, 0); + $cond=$28; + var $29=$cond; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 22; break; + case 9: + var $33=$2; + var $34=(($33+4)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)!=41; + if ($36) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $38=$2; + _parseerror($38, ((STRING_TABLE.__str161)|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)); + var $39=$cond; + var $40=$39; + var $41=$40; + var $42=(($41+8)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$cond; + var $45=$44; + FUNCTION_TABLE[$43]($45); + $1=0; + __label__ = 22; break; + case 11: + var $47=$2; + var $48=_parser_next($47); + if ($48) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + var $50=$2; + _parseerror($50, ((STRING_TABLE.__str162)|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)); + var $51=$cond; + var $52=$51; + var $53=$52; + var $54=(($53+8)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$cond; + var $57=$56; + FUNCTION_TABLE[$55]($57); + $1=0; + __label__ = 22; break; + case 13: + var $59=$2; + var $60=_parse_statement_or_block($59); + $ontrue=$60; + var $61=$ontrue; + var $62=(($61)|0)!=0; + if ($62) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + var $64=$cond; + var $65=$64; + var $66=$65; + var $67=(($66+8)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$cond; + var $70=$69; + FUNCTION_TABLE[$68]($70); + $1=0; + __label__ = 22; break; + case 15: + var $72=$2; + var $73=(($72)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($74+292)|0); + var $76=(($75+4)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=_strcmp($77, ((STRING_TABLE.__str163)|0)); + var $79=(($78)|0)!=0; + if ($79) { __label__ = 21; break; } else { __label__ = 16; break; } + case 16: + var $81=$2; + var $82=_parser_next($81); + if ($82) { __label__ = 18; break; } else { __label__ = 17; break; } + case 17: + var $84=$2; + _parseerror($84, ((STRING_TABLE.__str164)|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)); + var $85=$ontrue; + var $86=$85; + var $87=$86; + var $88=(($87+8)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=$ontrue; + var $91=$90; + FUNCTION_TABLE[$89]($91); + var $92=$cond; + var $93=$92; + var $94=$93; + var $95=(($94+8)|0); + var $96=HEAP32[(($95)>>2)]; + var $97=$cond; + var $98=$97; + FUNCTION_TABLE[$96]($98); + $1=0; + __label__ = 22; break; + case 18: + var $100=$2; + var $101=_parse_statement_or_block($100); + $onfalse=$101; + var $102=$onfalse; + var $103=(($102)|0)!=0; + if ($103) { __label__ = 20; break; } else { __label__ = 19; break; } + case 19: + var $105=$ontrue; + var $106=$105; + var $107=$106; + var $108=(($107+8)|0); + var $109=HEAP32[(($108)>>2)]; + var $110=$ontrue; + var $111=$110; + FUNCTION_TABLE[$109]($111); + var $112=$cond; + var $113=$112; + var $114=$113; + var $115=(($114+8)|0); + var $116=HEAP32[(($115)>>2)]; + var $117=$cond; + var $118=$117; + FUNCTION_TABLE[$116]($118); + $1=0; + __label__ = 22; break; + case 20: + __label__ = 21; break; + case 21: + var $121=$cond; + var $122=$ontrue; + var $123=$onfalse; + var $124=(($ctx)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=(($ctx+4)|0); + var $127=HEAP32[(($126)>>2)]; + var $128=_ast_ifthen_new($125, $127, $121, $122, $123); + $ifthen=$128; + var $129=$ifthen; + var $130=$129; + var $131=$4; + HEAP32[(($131)>>2)]=$130; + $1=1; + __label__ = 22; break; + case 22: + var $133=$1; + STACKTOP = __stackBase__; + return $133; + default: assert(0, "bad label: " + __label__); + } +} +_parse_if["X"]=1; + +function _parse_while($parser, $block, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $aloop; + var $cond; + var $ontrue; + var $ctx=__stackBase__; + $2=$parser; + $3=$block; + $4=$out; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=$ctx; + var $11=$9; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=$2; + var $13=_parser_next($12); + if ($13) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $15=$2; + var $16=(($15+4)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0)!=40; + if ($18) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $20=$2; + _parseerror($20, ((STRING_TABLE.__str154)|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)); + $1=0; + __label__ = 16; break; + case 5: + var $22=$2; + var $23=_parser_next($22); + if ($23) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $25=$2; + _parseerror($25, ((STRING_TABLE.__str155)|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)); + $1=0; + __label__ = 16; break; + case 7: + var $27=$2; + var $28=_parse_expression_leave($27, 0); + $cond=$28; + var $29=$cond; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 16; break; + case 9: + var $33=$2; + var $34=(($33+4)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35)|0)!=41; + if ($36) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $38=$2; + _parseerror($38, ((STRING_TABLE.__str156)|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)); + var $39=$cond; + var $40=$39; + var $41=$40; + var $42=(($41+8)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$cond; + var $45=$44; + FUNCTION_TABLE[$43]($45); + $1=0; + __label__ = 16; break; + case 11: + var $47=$2; + var $48=_parser_next($47); + if ($48) { __label__ = 13; break; } else { __label__ = 12; break; } + case 12: + var $50=$2; + _parseerror($50, ((STRING_TABLE.__str158)|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)); + var $51=$cond; + var $52=$51; + var $53=$52; + var $54=(($53+8)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=$cond; + var $57=$56; + FUNCTION_TABLE[$55]($57); + $1=0; + __label__ = 16; break; + case 13: + var $59=$2; + var $60=_parse_statement_or_block($59); + $ontrue=$60; + var $61=$ontrue; + var $62=(($61)|0)!=0; + if ($62) { __label__ = 15; break; } else { __label__ = 14; break; } + case 14: + var $64=$cond; + var $65=$64; + var $66=$65; + var $67=(($66+8)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$cond; + var $70=$69; + FUNCTION_TABLE[$68]($70); + $1=0; + __label__ = 16; break; + case 15: + var $72=$cond; + var $73=$ontrue; + var $74=(($ctx)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=(($ctx+4)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=_ast_loop_new($75, $77, 0, $72, 0, 0, $73); + $aloop=$78; + var $79=$aloop; + var $80=$79; + var $81=$4; + HEAP32[(($81)>>2)]=$80; + $1=1; + __label__ = 16; break; + case 16: + var $83=$1; + STACKTOP = __stackBase__; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_parse_while["X"]=1; + +function _parse_dowhile($parser, $block, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $aloop; + var $cond; + var $ontrue; + var $ctx=__stackBase__; + $2=$parser; + $3=$block; + $4=$out; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=$ctx; + var $11=$9; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=$2; + var $13=_parser_next($12); + if ($13) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $15=$2; + _parseerror($15, ((STRING_TABLE.__str152724)|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)); + $1=0; + __label__ = 24; break; + case 4: + var $17=$2; + var $18=_parse_statement_or_block($17); + $ontrue=$18; + var $19=$ontrue; + var $20=(($19)|0)!=0; + if ($20) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 24; break; + case 6: + var $23=$2; + var $24=(($23+4)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)!=132; + if ($26) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $28=$2; + var $29=(($28)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+292)|0); + var $32=(($31+4)|0); + var $33=HEAP32[(($32)>>2)]; + var $34=_strcmp($33, ((STRING_TABLE.__str138710)|0)); + var $35=(($34)|0)!=0; + if ($35) { __label__ = 8; break; } else { __label__ = 9; break; } + case 8: + var $37=$2; + _parseerror($37, ((STRING_TABLE.__str153725)|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)); + var $38=$ontrue; + var $39=$38; + var $40=$39; + var $41=(($40+8)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$ontrue; + var $44=$43; + FUNCTION_TABLE[$42]($44); + $1=0; + __label__ = 24; break; + case 9: + var $46=$2; + var $47=_parser_next($46); + if ($47) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $49=$2; + var $50=(($49+4)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=(($51)|0)!=40; + if ($52) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $54=$2; + _parseerror($54, ((STRING_TABLE.__str154)|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)); + var $55=$ontrue; + var $56=$55; + var $57=$56; + var $58=(($57+8)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=$ontrue; + var $61=$60; + FUNCTION_TABLE[$59]($61); + $1=0; + __label__ = 24; break; + case 12: + var $63=$2; + var $64=_parser_next($63); + if ($64) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + var $66=$2; + _parseerror($66, ((STRING_TABLE.__str155)|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)); + var $67=$ontrue; + var $68=$67; + var $69=$68; + var $70=(($69+8)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$ontrue; + var $73=$72; + FUNCTION_TABLE[$71]($73); + $1=0; + __label__ = 24; break; + case 14: + var $75=$2; + var $76=_parse_expression_leave($75, 0); + $cond=$76; + var $77=$cond; + var $78=(($77)|0)!=0; + if ($78) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + $1=0; + __label__ = 24; break; + case 16: + var $81=$2; + var $82=(($81+4)|0); + var $83=HEAP32[(($82)>>2)]; + var $84=(($83)|0)!=41; + if ($84) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $86=$2; + _parseerror($86, ((STRING_TABLE.__str156)|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)); + var $87=$ontrue; + var $88=$87; + var $89=$88; + var $90=(($89+8)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=$ontrue; + var $93=$92; + FUNCTION_TABLE[$91]($93); + var $94=$cond; + var $95=$94; + var $96=$95; + var $97=(($96+8)|0); + var $98=HEAP32[(($97)>>2)]; + var $99=$cond; + var $100=$99; + FUNCTION_TABLE[$98]($100); + $1=0; + __label__ = 24; break; + case 18: + var $102=$2; + var $103=_parser_next($102); + if ($103) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $105=$2; + var $106=(($105+4)|0); + var $107=HEAP32[(($106)>>2)]; + var $108=(($107)|0)!=59; + if ($108) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + var $110=$2; + _parseerror($110, ((STRING_TABLE.__str157)|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)); + var $111=$ontrue; + var $112=$111; + var $113=$112; + var $114=(($113+8)|0); + var $115=HEAP32[(($114)>>2)]; + var $116=$ontrue; + var $117=$116; + FUNCTION_TABLE[$115]($117); + var $118=$cond; + var $119=$118; + var $120=$119; + var $121=(($120+8)|0); + var $122=HEAP32[(($121)>>2)]; + var $123=$cond; + var $124=$123; + FUNCTION_TABLE[$122]($124); + $1=0; + __label__ = 24; break; + case 21: + var $126=$2; + var $127=_parser_next($126); + if ($127) { __label__ = 23; break; } else { __label__ = 22; break; } + case 22: + var $129=$2; + _parseerror($129, ((STRING_TABLE.__str4576)|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)); + var $130=$ontrue; + var $131=$130; + var $132=$131; + var $133=(($132+8)|0); + var $134=HEAP32[(($133)>>2)]; + var $135=$ontrue; + var $136=$135; + FUNCTION_TABLE[$134]($136); + var $137=$cond; + var $138=$137; + var $139=$138; + var $140=(($139+8)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=$cond; + var $143=$142; + FUNCTION_TABLE[$141]($143); + $1=0; + __label__ = 24; break; + case 23: + var $145=$cond; + var $146=$ontrue; + var $147=(($ctx)|0); + var $148=HEAP32[(($147)>>2)]; + var $149=(($ctx+4)|0); + var $150=HEAP32[(($149)>>2)]; + var $151=_ast_loop_new($148, $150, 0, 0, $145, 0, $146); + $aloop=$151; + var $152=$aloop; + var $153=$152; + var $154=$4; + HEAP32[(($154)>>2)]=$153; + $1=1; + __label__ = 24; break; + case 24: + var $156=$1; + STACKTOP = __stackBase__; + return $156; + default: assert(0, "bad label: " + __label__); + } +} +_parse_dowhile["X"]=1; + +function _parse_for($parser, $block, $out) { + var __stackBase__ = STACKTOP; STACKTOP += 8; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $aloop; + var $initexpr; + var $cond; + var $increment; + var $ontrue; + var $oldblocklocal; + var $retval; + var $ctx=__stackBase__; + $2=$parser; + $3=$block; + $4=$out; + $retval=1; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=$ctx; + var $11=$9; + assert(8 % 1 === 0, 'memcpy given ' + 8 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($10)>>2)]=HEAP32[(($11)>>2)];HEAP32[((($10)+(4))>>2)]=HEAP32[((($11)+(4))>>2)]; + var $12=$2; + var $13=(($12+112)|0); + var $14=HEAP32[(($13)>>2)]; + $oldblocklocal=$14; + var $15=$2; + var $16=(($15+104)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=$2; + var $19=(($18+112)|0); + HEAP32[(($19)>>2)]=$17; + $initexpr=0; + $cond=0; + $increment=0; + $ontrue=0; + var $20=$2; + var $21=_parser_next($20); + if ($21) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $23=$2; + var $24=(($23+4)|0); + var $25=HEAP32[(($24)>>2)]; + var $26=(($25)|0)!=40; + if ($26) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $28=$2; + _parseerror($28, ((STRING_TABLE.__str144716)|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)); + __label__ = 52; break; + case 5: + var $30=$2; + var $31=_parser_next($30); + if ($31) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $33=$2; + _parseerror($33, ((STRING_TABLE.__str145717)|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)); + __label__ = 52; break; + case 7: + var $35=$2; + var $36=(($35+4)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)|0)==130; + if ($38) { __label__ = 8; break; } else { __label__ = 13; break; } + case 8: + var $40=HEAP32[((_opts_standard)>>2)]; + var $41=(($40)|0)!=3; + if ($41) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $43=$2; + var $44=_parsewarning($43, 4, ((STRING_TABLE.__str146718)|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)); + if ($44) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + __label__ = 52; break; + case 11: + __label__ = 12; break; + case 12: + var $48=$2; + _parseerror($48, ((STRING_TABLE.__str147719)|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)); + __label__ = 52; break; + case 13: + var $50=$2; + var $51=(($50+4)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($52)|0)!=59; + if ($53) { __label__ = 14; break; } else { __label__ = 17; break; } + case 14: + var $55=$2; + var $56=_parse_expression_leave($55, 0); + $initexpr=$56; + var $57=$initexpr; + var $58=(($57)|0)!=0; + if ($58) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + __label__ = 52; break; + case 16: + __label__ = 17; break; + case 17: + __label__ = 18; break; + case 18: + var $63=$2; + var $64=(($63+4)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=(($65)|0)!=59; + if ($66) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $68=$2; + _parseerror($68, ((STRING_TABLE.__str148720)|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)); + __label__ = 52; break; + case 20: + var $70=$2; + var $71=_parser_next($70); + if ($71) { __label__ = 22; break; } else { __label__ = 21; break; } + case 21: + var $73=$2; + _parseerror($73, ((STRING_TABLE.__str149721)|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)); + __label__ = 52; break; + case 22: + var $75=$2; + var $76=(($75+4)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=(($77)|0)!=59; + if ($78) { __label__ = 23; break; } else { __label__ = 26; break; } + case 23: + var $80=$2; + var $81=_parse_expression_leave($80, 0); + $cond=$81; + var $82=$cond; + var $83=(($82)|0)!=0; + if ($83) { __label__ = 25; break; } else { __label__ = 24; break; } + case 24: + __label__ = 52; break; + case 25: + __label__ = 26; break; + case 26: + var $87=$2; + var $88=(($87+4)|0); + var $89=HEAP32[(($88)>>2)]; + var $90=(($89)|0)!=59; + if ($90) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + var $92=$2; + _parseerror($92, ((STRING_TABLE.__str148720)|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)); + __label__ = 52; break; + case 28: + var $94=$2; + var $95=_parser_next($94); + if ($95) { __label__ = 30; break; } else { __label__ = 29; break; } + case 29: + var $97=$2; + _parseerror($97, ((STRING_TABLE.__str149721)|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)); + __label__ = 52; break; + case 30: + var $99=$2; + var $100=(($99+4)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=(($101)|0)!=41; + if ($102) { __label__ = 31; break; } else { __label__ = 40; break; } + case 31: + var $104=$2; + var $105=_parse_expression_leave($104, 0); + $increment=$105; + var $106=$increment; + var $107=(($106)|0)!=0; + if ($107) { __label__ = 33; break; } else { __label__ = 32; break; } + case 32: + __label__ = 52; break; + case 33: + var $110=$increment; + var $111=$110; + var $112=(($111+12)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=(($113)|0)==6; + if ($114) { __label__ = 39; break; } else { __label__ = 34; break; } + case 34: + var $116=$increment; + var $117=$116; + var $118=(($117+12)|0); + var $119=HEAP32[(($118)>>2)]; + var $120=(($119)|0)==12; + if ($120) { __label__ = 39; break; } else { __label__ = 35; break; } + case 35: + var $122=$increment; + var $123=$122; + var $124=(($123+12)|0); + var $125=HEAP32[(($124)>>2)]; + var $126=(($125)|0)==7; + if ($126) { __label__ = 39; break; } else { __label__ = 36; break; } + case 36: + var $128=$increment; + var $129=$128; + var $130=(($129)|0); + var $131=(($130)|0); + var $132=HEAP32[(($131)>>2)]; + var $133=(($130+4)|0); + var $134=HEAP32[(($133)>>2)]; + var $135=_genwarning($132, $134, 14, ((STRING_TABLE.__str143715)|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)); + if ($135) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + __label__ = 52; break; + case 38: + __label__ = 39; break; + case 39: + __label__ = 40; break; + case 40: + var $140=$2; + var $141=(($140+4)|0); + var $142=HEAP32[(($141)>>2)]; + var $143=(($142)|0)!=41; + if ($143) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + var $145=$2; + _parseerror($145, ((STRING_TABLE.__str150722)|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)); + __label__ = 52; break; + case 42: + var $147=$2; + var $148=_parser_next($147); + if ($148) { __label__ = 44; break; } else { __label__ = 43; break; } + case 43: + var $150=$2; + _parseerror($150, ((STRING_TABLE.__str151723)|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)); + __label__ = 52; break; + case 44: + var $152=$2; + var $153=_parse_statement_or_block($152); + $ontrue=$153; + var $154=$ontrue; + var $155=(($154)|0)!=0; + if ($155) { __label__ = 46; break; } else { __label__ = 45; break; } + case 45: + __label__ = 52; break; + case 46: + var $158=$initexpr; + var $159=$cond; + var $160=$increment; + var $161=$ontrue; + var $162=(($ctx)|0); + var $163=HEAP32[(($162)>>2)]; + var $164=(($ctx+4)|0); + var $165=HEAP32[(($164)>>2)]; + var $166=_ast_loop_new($163, $165, $158, $159, 0, $160, $161); + $aloop=$166; + var $167=$aloop; + var $168=$167; + var $169=$4; + HEAP32[(($169)>>2)]=$168; + __label__ = 47; break; + case 47: + var $171=$2; + var $172=(($171+104)|0); + var $173=HEAP32[(($172)>>2)]; + var $174=$2; + var $175=(($174+112)|0); + var $176=HEAP32[(($175)>>2)]; + var $177=(($173)>>>0) > (($176)>>>0); + if ($177) { __label__ = 48; break; } else { __label__ = 51; break; } + case 48: + var $179=$retval; + var $180=(($179) & 1); + if ($180) { __label__ = 49; break; } else { var $185 = 0;__label__ = 50; break; } + case 49: + var $182=$2; + var $183=_parser_pop_local($182); + var $185 = $183;__label__ = 50; break; + case 50: + var $185; + var $186=(($185)&1); + $retval=$186; + __label__ = 47; break; + case 51: + var $188=$oldblocklocal; + var $189=$2; + var $190=(($189+112)|0); + HEAP32[(($190)>>2)]=$188; + var $191=$retval; + var $192=(($191) & 1); + $1=$192; + __label__ = 62; break; + case 52: + var $194=$initexpr; + var $195=(($194)|0)!=0; + if ($195) { __label__ = 53; break; } else { __label__ = 54; break; } + case 53: + var $197=$initexpr; + var $198=$197; + var $199=$198; + var $200=(($199+8)|0); + var $201=HEAP32[(($200)>>2)]; + var $202=$initexpr; + var $203=$202; + FUNCTION_TABLE[$201]($203); + __label__ = 54; break; + case 54: + var $205=$cond; + var $206=(($205)|0)!=0; + if ($206) { __label__ = 55; break; } else { __label__ = 56; break; } + case 55: + var $208=$cond; + var $209=$208; + var $210=$209; + var $211=(($210+8)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=$cond; + var $214=$213; + FUNCTION_TABLE[$212]($214); + __label__ = 56; break; + case 56: + var $216=$increment; + var $217=(($216)|0)!=0; + if ($217) { __label__ = 57; break; } else { __label__ = 58; break; } + case 57: + var $219=$increment; + var $220=$219; + var $221=$220; + var $222=(($221+8)|0); + var $223=HEAP32[(($222)>>2)]; + var $224=$increment; + var $225=$224; + FUNCTION_TABLE[$223]($225); + __label__ = 58; break; + case 58: + __label__ = 59; break; + case 59: + var $228=$2; + var $229=(($228+104)|0); + var $230=HEAP32[(($229)>>2)]; + var $231=$2; + var $232=(($231+112)|0); + var $233=HEAP32[(($232)>>2)]; + var $234=(($230)>>>0) > (($233)>>>0); + if ($234) { __label__ = 60; break; } else { __label__ = 61; break; } + case 60: + var $236=$2; + var $237=_parser_pop_local($236); + var $238=$237 ^ 1; + var $239=(($238)&1); + __label__ = 59; break; + case 61: + var $241=$oldblocklocal; + var $242=$2; + var $243=(($242+112)|0); + HEAP32[(($243)>>2)]=$241; + $1=0; + __label__ = 62; break; + case 62: + var $245=$1; + STACKTOP = __stackBase__; + return $245; + default: assert(0, "bad label: " + __label__); + } +} +_parse_for["X"]=1; + +function _parse_block($parser, $warnreturn) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $block; + $2=$parser; + var $4=(($warnreturn)&1); + $3=$4; + var $5=$2; + var $6=(($5)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($7+292)|0); + var $9=(($8+28)|0); + var $10=(($9)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($9+4)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=_ast_block_new($11, $13); + $block=$14; + var $15=$block; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $19=$2; + var $20=$block; + var $21=$3; + var $22=(($21) & 1); + var $23=_parse_block_into($19, $20, $22); + if ($23) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $25=$block; + _ast_block_delete($25); + $1=0; + __label__ = 7; break; + case 6: + var $27=$block; + $1=$27; + __label__ = 7; break; + case 7: + var $29=$1; + ; + return $29; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parse_statement_or_block($parser) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $expr=__stackBase__; + $2=$parser; + HEAP32[(($expr)>>2)]=0; + var $3=$2; + var $4=(($3+4)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($5)|0)==123; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $8=$2; + var $9=_parse_block($8, 0); + var $10=$9; + $1=$10; + __label__ = 7; break; + case 4: + var $12=$2; + var $13=_parse_statement($12, 0, $expr); + if ($13) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=0; + __label__ = 7; break; + case 6: + var $16=HEAP32[(($expr)>>2)]; + $1=$16; + __label__ = 7; break; + case 7: + var $18=$1; + STACKTOP = __stackBase__; + return $18; + default: assert(0, "bad label: " + __label__); + } +} + + +function _parser_find_param($parser, $name) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $fun; + $2=$parser; + $3=$name; + var $4=$2; + var $5=(($4+96)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 11; break; + case 4: + var $10=$2; + var $11=(($10+96)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($12+20)|0); + var $14=HEAP32[(($13)>>2)]; + $fun=$14; + $i=0; + __label__ = 5; break; + case 5: + var $16=$i; + var $17=$fun; + var $18=(($17)|0); + var $19=(($18+36)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=(($16)>>>0) < (($20)>>>0); + if ($21) { __label__ = 6; break; } else { __label__ = 10; break; } + case 6: + var $23=$i; + var $24=$fun; + var $25=(($24)|0); + var $26=(($25+32)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27+($23<<2))|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+56)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=$3; + var $33=_strcmp($31, $32); + var $34=(($33)|0)!=0; + if ($34) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $36=$i; + var $37=$fun; + var $38=(($37)|0); + var $39=(($38+32)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40+($36<<2))|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$42; + $1=$43; + __label__ = 11; break; + case 8: + __label__ = 9; break; + case 9: + var $46=$i; + var $47=((($46)+(1))|0); + $i=$47; + __label__ = 5; break; + case 10: + $1=0; + __label__ = 11; break; + case 11: + var $50=$1; + ; + return $50; + default: assert(0, "bad label: " + __label__); + } +} +_parser_find_param["X"]=1; + +function _util_memory_a($byte, $line, $file) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $info; + var $data; + $2=$byte; + $3=$line; + $4=$file; + var $5=$2; + var $6=((($5)+(20))|0); + var $7=_malloc($6); + var $8=$7; + $info=$8; + var $9=$info; + var $10=(($9+20)|0); + var $11=$10; + $data=$11; + var $12=$info; + var $13=(($12)|0)!=0; + if ($13) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 7; break; + case 4: + var $16=$3; + var $17=$info; + var $18=(($17+4)|0); + HEAP32[(($18)>>2)]=$16; + var $19=$2; + var $20=$info; + var $21=(($20+8)|0); + HEAP32[(($21)>>2)]=$19; + var $22=$4; + var $23=$info; + var $24=(($23)|0); + HEAP32[(($24)>>2)]=$22; + var $25=$info; + var $26=(($25+16)|0); + HEAP32[(($26)>>2)]=0; + var $27=HEAP32[((_mem_start)>>2)]; + var $28=$info; + var $29=(($28+12)|0); + HEAP32[(($29)>>2)]=$27; + var $30=HEAP32[((_mem_start)>>2)]; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $33=$info; + var $34=HEAP32[((_mem_start)>>2)]; + var $35=(($34+16)|0); + HEAP32[(($35)>>2)]=$33; + __label__ = 6; break; + case 6: + var $37=$info; + HEAP32[((_mem_start)>>2)]=$37; + var $38=$2; + var $39=$data; + var $40=$4; + var $41=$3; + _util_debug(((STRING_TABLE.__str736)|0), ((STRING_TABLE.__str1737)|0), (tempInt=STACKTOP,STACKTOP += 16,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$38,HEAP32[(((tempInt)+(4))>>2)]=$39,HEAP32[(((tempInt)+(8))>>2)]=$40,HEAP32[(((tempInt)+(12))>>2)]=$41,tempInt)); + var $st$7$0=((_mem_at)|0); + var $42$0=HEAP32[(($st$7$0)>>2)]; + var $st$7$1=((_mem_at+4)|0); + var $42$1=HEAP32[(($st$7$1)>>2)]; + var $$emscripten$temp$0$0=1; + var $$emscripten$temp$0$1=0; + var $43$0 = (i64Math.add($42$0,$42$1,$$emscripten$temp$0$0,$$emscripten$temp$0$1),i64Math.result[0]); var $43$1 = i64Math.result[1]; + var $st$14$0=((_mem_at)|0); + HEAP32[(($st$14$0)>>2)]=$43$0; + var $st$14$1=((_mem_at+4)|0); + HEAP32[(($st$14$1)>>2)]=$43$1; + var $44=$info; + var $45=(($44+8)|0); + var $46=HEAP32[(($45)>>2)]; + var $47$0=$46; + var $47$1=0; + var $st$23$0=((_mem_ab)|0); + var $48$0=HEAP32[(($st$23$0)>>2)]; + var $st$23$1=((_mem_ab+4)|0); + var $48$1=HEAP32[(($st$23$1)>>2)]; + var $49$0 = (i64Math.add($48$0,$48$1,$47$0,$47$1),i64Math.result[0]); var $49$1 = i64Math.result[1]; + var $st$28$0=((_mem_ab)|0); + HEAP32[(($st$28$0)>>2)]=$49$0; + var $st$28$1=((_mem_ab+4)|0); + HEAP32[(($st$28$1)>>2)]=$49$1; + var $50=$data; + $1=$50; + __label__ = 7; break; + case 7: + var $52=$1; + STACKTOP = __stackBase__; + return $52; + default: assert(0, "bad label: " + __label__); + } +} +_util_memory_a["X"]=1; + +function _util_debug($area, $ms) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $va=__stackBase__; + $1=$area; + $2=$ms; + var $3=HEAP8[(_opts_debug)]; + var $4=(($3) & 1); + if ($4) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + __label__ = 8; break; + case 4: + var $7=$1; + var $8=_strcmp($7, ((STRING_TABLE.__str736)|0)); + var $9=(($8)|0)!=0; + if ($9) { __label__ = 7; break; } else { __label__ = 5; break; } + case 5: + var $11=HEAP8[(_opts_memchk)]; + var $12=(($11) & 1); + if ($12) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + __label__ = 8; break; + case 7: + var $15=$va; + HEAP32[(($15)>>2)]=arguments[_util_debug.length]; + var $16=HEAP32[((_stdout)>>2)]; + var $17=_fprintf($16, ((STRING_TABLE.__str7743)|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)); + var $18=HEAP32[((_stdout)>>2)]; + var $19=_fputc(91, $18); + var $20=HEAP32[((_stdout)>>2)]; + var $21=$1; + var $22=_fprintf($20, ((STRING_TABLE.__str8744)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$21,tempInt)); + var $23=HEAP32[((_stdout)>>2)]; + var $24=_fputs(((STRING_TABLE.__str9745)|0), $23); + var $25=HEAP32[((_stdout)>>2)]; + var $26=$2; + var $27=HEAP32[(($va)>>2)]; + var $28=_vfprintf($25, $26, $27); + var $29=$va; + ; + __label__ = 8; break; + case 8: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} + + +function _util_endianswap($m, $s, $l) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2=__stackBase__; + var $3; + var $w; + var $i; + var $p; + var $t; + $1=$m; + HEAP32[(($2)>>2)]=$s; + $3=$l; + $w=0; + $i=0; + var $4=$2; + var $5=HEAP8[($4)]; + var $6=(($5 << 24) >> 24)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + __label__ = 12; break; + case 4: + __label__ = 5; break; + case 5: + var $10=$w; + var $11=$3; + var $12=(($10)>>>0) < (($11)>>>0); + if ($12) { __label__ = 6; break; } else { __label__ = 12; break; } + case 6: + __label__ = 7; break; + case 7: + var $15=$i; + var $16=HEAP32[(($2)>>2)]; + var $17=$16 << 1; + var $18=(($15)>>>0) < (($17)>>>0); + if ($18) { __label__ = 8; break; } else { __label__ = 10; break; } + case 8: + var $20=$1; + var $21=$w; + var $22=HEAP32[(($2)>>2)]; + var $23=((($21)*($22))|0); + var $24=(($20+$23)|0); + $p=$24; + var $25=$i; + var $26=$p; + var $27=(($26+$25)|0); + var $28=HEAP8[($27)]; + $t=$28; + var $29=HEAP32[(($2)>>2)]; + var $30=$i; + var $31=((($29)-($30))|0); + var $32=((($31)-(1))|0); + var $33=$p; + var $34=(($33+$32)|0); + var $35=HEAP8[($34)]; + var $36=$i; + var $37=$p; + var $38=(($37+$36)|0); + HEAP8[($38)]=$35; + var $39=$t; + var $40=HEAP32[(($2)>>2)]; + var $41=$i; + var $42=((($40)-($41))|0); + var $43=((($42)-(1))|0); + var $44=$p; + var $45=(($44+$43)|0); + HEAP8[($45)]=$39; + __label__ = 9; break; + case 9: + var $47=$i; + var $48=((($47)+(1))|0); + $i=$48; + __label__ = 7; break; + case 10: + __label__ = 11; break; + case 11: + var $51=$w; + var $52=((($51)+(1))|0); + $w=$52; + __label__ = 5; break; + case 12: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_util_endianswap["X"]=1; + +function _util_crc16($current, $k, $len) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $h; + $1=$current; + $2=$k; + $3=$len; + var $4=$1; + $h=$4; + __label__ = 3; break; + case 3: + var $6=$3; + var $7=(($6)|0)!=0; + if ($7) { __label__ = 4; break; } else { __label__ = 6; break; } + case 4: + var $9=$h; + var $10=(($9)&65535); + var $11=$10 >> 8; + var $12=$2; + var $13=HEAP8[($12)]; + var $14=(($13)&255); + var $15=$11 ^ $14; + var $16=((_util_crc16_table+($15<<1))|0); + var $17=HEAP16[(($16)>>1)]; + var $18=(($17)&65535); + var $19=$h; + var $20=(($19)&65535); + var $21=$20 << 8; + var $22=$18 ^ $21; + var $23=(($22) & 65535); + $h=$23; + __label__ = 5; break; + case 5: + var $25=$3; + var $26=((($25)-(1))|0); + $3=$26; + var $27=$2; + var $28=(($27+1)|0); + $2=$28; + __label__ = 3; break; + case 6: + var $30=$h; + ; + return $30; + default: assert(0, "bad label: " + __label__); + } +} + + +function _util_memory_d($ptrn, $line, $file) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $info; + $1=$ptrn; + $2=$line; + $3=$file; + $info=0; + var $4=$1; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + __label__ = 11; break; + case 4: + var $8=$1; + var $9=$8; + var $10=((($9)-(20))|0); + $info=$10; + var $11=$info; + var $12=(($11+8)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=$1; + var $15=$3; + var $16=$2; + _util_debug(((STRING_TABLE.__str736)|0), ((STRING_TABLE.__str2738)|0), (tempInt=STACKTOP,STACKTOP += 16,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$13,HEAP32[(((tempInt)+(4))>>2)]=$14,HEAP32[(((tempInt)+(8))>>2)]=$15,HEAP32[(((tempInt)+(12))>>2)]=$16,tempInt)); + var $17=$info; + var $18=(($17+8)|0); + var $19=HEAP32[(($18)>>2)]; + var $20$0=$19; + var $20$1=0; + var $st$16$0=((_mem_db)|0); + var $21$0=HEAP32[(($st$16$0)>>2)]; + var $st$16$1=((_mem_db+4)|0); + var $21$1=HEAP32[(($st$16$1)>>2)]; + var $22$0 = (i64Math.add($21$0,$21$1,$20$0,$20$1),i64Math.result[0]); var $22$1 = i64Math.result[1]; + var $st$21$0=((_mem_db)|0); + HEAP32[(($st$21$0)>>2)]=$22$0; + var $st$21$1=((_mem_db+4)|0); + HEAP32[(($st$21$1)>>2)]=$22$1; + var $st$25$0=((_mem_dt)|0); + var $23$0=HEAP32[(($st$25$0)>>2)]; + var $st$25$1=((_mem_dt+4)|0); + var $23$1=HEAP32[(($st$25$1)>>2)]; + var $$emscripten$temp$0$0=1; + var $$emscripten$temp$0$1=0; + var $24$0 = (i64Math.add($23$0,$23$1,$$emscripten$temp$0$0,$$emscripten$temp$0$1),i64Math.result[0]); var $24$1 = i64Math.result[1]; + var $st$32$0=((_mem_dt)|0); + HEAP32[(($st$32$0)>>2)]=$24$0; + var $st$32$1=((_mem_dt+4)|0); + HEAP32[(($st$32$1)>>2)]=$24$1; + var $25=$info; + var $26=(($25+16)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27)|0)!=0; + if ($28) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $30=$info; + var $31=(($30+12)|0); + var $32=HEAP32[(($31)>>2)]; + var $33=$info; + var $34=(($33+16)|0); + var $35=HEAP32[(($34)>>2)]; + var $36=(($35+12)|0); + HEAP32[(($36)>>2)]=$32; + __label__ = 6; break; + case 6: + var $38=$info; + var $39=(($38+12)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40)|0)!=0; + if ($41) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $43=$info; + var $44=(($43+16)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=$info; + var $47=(($46+12)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=(($48+16)|0); + HEAP32[(($49)>>2)]=$45; + __label__ = 8; break; + case 8: + var $51=$info; + var $52=HEAP32[((_mem_start)>>2)]; + var $53=(($51)|0)==(($52)|0); + if ($53) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $55=$info; + var $56=(($55+12)|0); + var $57=HEAP32[(($56)>>2)]; + HEAP32[((_mem_start)>>2)]=$57; + __label__ = 10; break; + case 10: + var $59=$info; + var $60=$59; + _free($60); + __label__ = 11; break; + case 11: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_util_memory_d["X"]=1; + +function _util_meminfo() { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $info; + var $1=HEAP8[(_opts_memchk)]; + var $2=(($1) & 1); + if ($2) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + __label__ = 9; break; + case 4: + var $5=HEAP32[((_mem_start)>>2)]; + $info=$5; + __label__ = 5; break; + case 5: + var $7=$info; + var $8=(($7)|0)!=0; + if ($8) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $10=$info; + var $11=(($10+8)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=$info; + var $14=(($13)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$info; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + _util_debug(((STRING_TABLE.__str736)|0), ((STRING_TABLE.__str4740)|0), (tempInt=STACKTOP,STACKTOP += 12,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$12,HEAP32[(((tempInt)+(4))>>2)]=$15,HEAP32[(((tempInt)+(8))>>2)]=$18,tempInt)); + __label__ = 7; break; + case 7: + var $20=$info; + var $21=(($20+12)|0); + var $22=HEAP32[(($21)>>2)]; + $info=$22; + __label__ = 5; break; + case 8: + var $st$0$0=((_mem_at)|0); + var $24$0=HEAP32[(($st$0$0)>>2)]; + var $st$0$1=((_mem_at+4)|0); + var $24$1=HEAP32[(($st$0$1)>>2)]; + var $st$4$0=((_mem_dt)|0); + var $25$0=HEAP32[(($st$4$0)>>2)]; + var $st$4$1=((_mem_dt+4)|0); + var $25$1=HEAP32[(($st$4$1)>>2)]; + var $st$8$0=((_mem_ab)|0); + var $26$0=HEAP32[(($st$8$0)>>2)]; + var $st$8$1=((_mem_ab+4)|0); + var $26$1=HEAP32[(($st$8$1)>>2)]; + var $st$12$0=((_mem_db)|0); + var $27$0=HEAP32[(($st$12$0)>>2)]; + var $st$12$1=((_mem_db+4)|0); + var $27$1=HEAP32[(($st$12$1)>>2)]; + var $st$16$0=((_mem_ab)|0); + var $28$0=HEAP32[(($st$16$0)>>2)]; + var $st$16$1=((_mem_ab+4)|0); + var $28$1=HEAP32[(($st$16$1)>>2)]; + var $st$20$0=((_mem_db)|0); + var $29$0=HEAP32[(($st$20$0)>>2)]; + var $st$20$1=((_mem_db+4)|0); + var $29$1=HEAP32[(($st$20$1)>>2)]; + var $30$0 = (i64Math.subtract($28$0,$28$1,$29$0,$29$1),i64Math.result[0]); var $30$1 = i64Math.result[1]; + var $st$25$0=((_mem_at)|0); + var $31$0=HEAP32[(($st$25$0)>>2)]; + var $st$25$1=((_mem_at+4)|0); + var $31$1=HEAP32[(($st$25$1)>>2)]; + var $st$29$0=((_mem_dt)|0); + var $32$0=HEAP32[(($st$29$0)>>2)]; + var $st$29$1=((_mem_dt+4)|0); + var $32$1=HEAP32[(($st$29$1)>>2)]; + var $33$0 = (i64Math.subtract($31$0,$31$1,$32$0,$32$1),i64Math.result[0]); var $33$1 = i64Math.result[1]; + var $$emscripten$temp$1=((STRING_TABLE.__str5741)|0); + var $$emscripten$temp$0=((STRING_TABLE.__str736)|0); + _util_debug($$emscripten$temp$0, $$emscripten$temp$1, (tempInt=STACKTOP,STACKTOP += 48,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$24$0,HEAP32[(((tempInt)+(4))>>2)]=$24$1,HEAP32[(((tempInt)+(8))>>2)]=$25$0,HEAP32[(((tempInt)+(12))>>2)]=$25$1,HEAP32[(((tempInt)+(16))>>2)]=$26$0,HEAP32[(((tempInt)+(20))>>2)]=$26$1,HEAP32[(((tempInt)+(24))>>2)]=$27$0,HEAP32[(((tempInt)+(28))>>2)]=$27$1,HEAP32[(((tempInt)+(32))>>2)]=$30$0,HEAP32[(((tempInt)+(36))>>2)]=$30$1,HEAP32[(((tempInt)+(40))>>2)]=$33$0,HEAP32[(((tempInt)+(44))>>2)]=$33$1,tempInt)); + __label__ = 9; break; + case 9: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_util_meminfo["X"]=1; + +function _util_strdup($s) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $len; + var $ptr; + $2=$s; + $len=0; + $ptr=0; + var $3=$2; + var $4=(($3)|0)!=0; + if ($4) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 8; break; + case 4: + var $7=$2; + var $8=_strlen($7); + $len=$8; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $11=$len; + var $12=((($11)+(1))|0); + var $13=_util_memory_a($12, 161, ((STRING_TABLE.__str6742)|0)); + $ptr=$13; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $16=$ptr; + var $17=$2; + var $18=$len; + assert($18 % 1 === 0, 'memcpy given ' + $18 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($16, $17, $18, 1); + var $19=$len; + var $20=$ptr; + var $21=(($20+$19)|0); + HEAP8[($21)]=0; + __label__ = 7; break; + case 7: + var $23=$ptr; + $1=$23; + __label__ = 8; break; + case 8: + var $25=$1; + ; + return $25; + default: assert(0, "bad label: " + __label__); + } +} + + +function _util_getline($lineptr, $n, $stream) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $chr; + var $ret; + var $pos; + var $c; + var $tmp; + $2=$lineptr; + $3=$n; + $4=$stream; + var $5=$2; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 3; break; } else { __label__ = 5; break; } + case 3: + var $8=$3; + var $9=(($8)|0)!=0; + if ($9) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + var $11=$4; + var $12=(($11)|0)!=0; + if ($12) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + $1=-1; + __label__ = 30; break; + case 6: + var $15=$2; + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 10; break; } else { __label__ = 7; break; } + case 7: + var $19=$3; + HEAP32[(($19)>>2)]=64; + var $20=_util_memory_a(64, 435, ((STRING_TABLE.__str6742)|0)); + var $21=$2; + HEAP32[(($21)>>2)]=$20; + var $22=(($20)|0)!=0; + if ($22) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=-1; + __label__ = 30; break; + case 9: + __label__ = 10; break; + case 10: + var $26=$3; + var $27=HEAP32[(($26)>>2)]; + $chr=$27; + var $28=$2; + var $29=HEAP32[(($28)>>2)]; + $pos=$29; + __label__ = 11; break; + case 11: + var $31=$4; + var $32=_getc($31); + $c=$32; + var $33=$chr; + var $34=(($33)|0) < 2; + if ($34) { __label__ = 12; break; } else { __label__ = 20; break; } + case 12: + var $36=$3; + var $37=HEAP32[(($36)>>2)]; + var $38=(($37)>>>0) > 16; + if ($38) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $40=$3; + var $41=HEAP32[(($40)>>2)]; + var $44 = $41;__label__ = 15; break; + case 14: + var $44 = 64;__label__ = 15; break; + case 15: + var $44; + var $45=$3; + var $46=HEAP32[(($45)>>2)]; + var $47=((($46)+($44))|0); + HEAP32[(($45)>>2)]=$47; + var $48=_util_memory_a($47, 446, ((STRING_TABLE.__str6742)|0)); + $tmp=$48; + var $49=$tmp; + var $50=(($49)|0)!=0; + if ($50) { __label__ = 17; break; } else { __label__ = 16; break; } + case 16: + $1=-1; + __label__ = 30; break; + case 17: + var $53=$tmp; + var $54=$2; + var $55=HEAP32[(($54)>>2)]; + var $56=$pos; + var $57=$2; + var $58=HEAP32[(($57)>>2)]; + var $59=$56; + var $60=$58; + var $61=((($59)-($60))|0); + assert($61 % 1 === 0, 'memcpy given ' + $61 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($53, $55, $61, 1); + var $62=$3; + var $63=HEAP32[(($62)>>2)]; + var $64=$2; + var $65=HEAP32[(($64)>>2)]; + var $66=(($65+$63)|0); + var $67=$pos; + var $68=$66; + var $69=$67; + var $70=((($68)-($69))|0); + $chr=$70; + var $71=$tmp; + var $72=$2; + HEAP32[(($72)>>2)]=$71; + var $73=(($71)|0)!=0; + if ($73) { __label__ = 19; break; } else { __label__ = 18; break; } + case 18: + var $75=$tmp; + _util_memory_d($75, 453, ((STRING_TABLE.__str6742)|0)); + $1=-1; + __label__ = 30; break; + case 19: + var $77=$3; + var $78=HEAP32[(($77)>>2)]; + var $79=$chr; + var $80=((($78)-($79))|0); + var $81=$2; + var $82=HEAP32[(($81)>>2)]; + var $83=(($82+$80)|0); + $pos=$83; + __label__ = 20; break; + case 20: + var $85=$4; + var $86=_ferror($85); + var $87=(($86)|0)!=0; + if ($87) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + $1=-1; + __label__ = 30; break; + case 22: + var $90=$c; + var $91=(($90)|0)==-1; + if ($91) { __label__ = 23; break; } else { __label__ = 26; break; } + case 23: + var $93=$pos; + var $94=$2; + var $95=HEAP32[(($94)>>2)]; + var $96=(($93)|0)==(($95)|0); + if ($96) { __label__ = 24; break; } else { __label__ = 25; break; } + case 24: + $1=-1; + __label__ = 30; break; + case 25: + __label__ = 29; break; + case 26: + var $100=$c; + var $101=(($100) & 255); + var $102=$pos; + var $103=(($102+1)|0); + $pos=$103; + HEAP8[($102)]=$101; + var $104=$chr; + var $105=((($104)-(1))|0); + $chr=$105; + var $106=$c; + var $107=(($106)|0)==10; + if ($107) { __label__ = 27; break; } else { __label__ = 28; break; } + case 27: + __label__ = 29; break; + case 28: + __label__ = 11; break; + case 29: + var $111=$pos; + HEAP8[($111)]=0; + var $112=$pos; + var $113=$2; + var $114=HEAP32[(($113)>>2)]; + var $115=$112; + var $116=$114; + var $117=((($115)-($116))|0); + $ret=$117; + $1=$117; + __label__ = 30; break; + case 30: + var $119=$1; + ; + return $119; + default: assert(0, "bad label: " + __label__); + } +} +_util_getline["X"]=1; + +function _util_strtocmd($in, $out, $outsz) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $sz; + $1=$in; + $2=$out; + $3=$outsz; + $sz=1; + __label__ = 3; break; + case 3: + var $5=$1; + var $6=HEAP8[($5)]; + var $7=(($6 << 24) >> 24); + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { var $14 = 0;__label__ = 5; break; } + case 4: + var $10=$sz; + var $11=$3; + var $12=(($10)>>>0) < (($11)>>>0); + var $14 = $12;__label__ = 5; break; + case 5: + var $14; + if ($14) { __label__ = 6; break; } else { __label__ = 15; break; } + case 6: + var $16=$1; + var $17=HEAP8[($16)]; + var $18=(($17 << 24) >> 24); + var $19=(($18)|0)==45; + if ($19) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $21=$2; + HEAP8[($21)]=95; + __label__ = 13; break; + case 8: + var $23=$1; + var $24=HEAP8[($23)]; + var $25=(($24 << 24) >> 24); + var $26=_isalpha($25); + var $27=(($26)|0)!=0; + if ($27) { __label__ = 9; break; } else { __label__ = 11; break; } + case 9: + var $29=$1; + var $30=HEAP8[($29)]; + var $31=(($30 << 24) >> 24); + var $32=_isupper($31); + var $33=(($32)|0)!=0; + if ($33) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + var $35=$1; + var $36=HEAP8[($35)]; + var $37=(($36 << 24) >> 24); + var $38=((($37)+(65))|0); + var $39=((($38)-(97))|0); + var $40=(($39) & 255); + var $41=$2; + HEAP8[($41)]=$40; + __label__ = 12; break; + case 11: + var $43=$1; + var $44=HEAP8[($43)]; + var $45=$2; + HEAP8[($45)]=$44; + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $49=$1; + var $50=(($49+1)|0); + $1=$50; + var $51=$2; + var $52=(($51+1)|0); + $2=$52; + var $53=$sz; + var $54=((($53)+(1))|0); + $sz=$54; + __label__ = 3; break; + case 15: + var $56=$2; + HEAP8[($56)]=0; + var $57=$sz; + var $58=((($57)-(1))|0); + ; + return $58; + default: assert(0, "bad label: " + __label__); + } +} +_util_strtocmd["X"]=1; + +function _util_strtononcmd($in, $out, $outsz) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $sz; + $1=$in; + $2=$out; + $3=$outsz; + $sz=1; + __label__ = 3; break; + case 3: + var $5=$1; + var $6=HEAP8[($5)]; + var $7=(($6 << 24) >> 24); + var $8=(($7)|0)!=0; + if ($8) { __label__ = 4; break; } else { var $14 = 0;__label__ = 5; break; } + case 4: + var $10=$sz; + var $11=$3; + var $12=(($10)>>>0) < (($11)>>>0); + var $14 = $12;__label__ = 5; break; + case 5: + var $14; + if ($14) { __label__ = 6; break; } else { __label__ = 15; break; } + case 6: + var $16=$1; + var $17=HEAP8[($16)]; + var $18=(($17 << 24) >> 24); + var $19=(($18)|0)==95; + if ($19) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $21=$2; + HEAP8[($21)]=45; + __label__ = 13; break; + case 8: + var $23=$1; + var $24=HEAP8[($23)]; + var $25=(($24 << 24) >> 24); + var $26=_isalpha($25); + var $27=(($26)|0)!=0; + if ($27) { __label__ = 9; break; } else { __label__ = 11; break; } + case 9: + var $29=$1; + var $30=HEAP8[($29)]; + var $31=(($30 << 24) >> 24); + var $32=_isupper($31); + var $33=(($32)|0)!=0; + if ($33) { __label__ = 10; break; } else { __label__ = 11; break; } + case 10: + var $35=$1; + var $36=HEAP8[($35)]; + var $37=(($36 << 24) >> 24); + var $38=((($37)+(97))|0); + var $39=((($38)-(65))|0); + var $40=(($39) & 255); + var $41=$2; + HEAP8[($41)]=$40; + __label__ = 12; break; + case 11: + var $43=$1; + var $44=HEAP8[($43)]; + var $45=$2; + HEAP8[($45)]=$44; + __label__ = 12; break; + case 12: + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $49=$1; + var $50=(($49+1)|0); + $1=$50; + var $51=$2; + var $52=(($51+1)|0); + $2=$52; + var $53=$sz; + var $54=((($53)+(1))|0); + $sz=$54; + __label__ = 3; break; + case 15: + var $56=$2; + HEAP8[($56)]=0; + var $57=$sz; + var $58=((($57)-(1))|0); + ; + return $58; + default: assert(0, "bad label: " + __label__); + } +} +_util_strtononcmd["X"]=1; + +function _util_fopen($filename, $mode) { + ; + var __label__; + + var $1; + var $2; + $1=$filename; + $2=$mode; + var $3=$1; + var $4=$2; + var $5=_fopen($3, $4); + ; + return $5; +} + + +function _malloc($bytes) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $mem; + var $nb; + var $idx; + var $smallbits; + var $b; + var $p; + var $F; + var $b1; + var $p2; + var $r; + var $rsize; + var $i; + var $leftbits; + var $leastbit; + var $Y; + var $K; + var $N; + var $F3; + var $DVS; + var $DV; + var $I; + var $B; + var $F4; + var $rsize5; + var $p6; + var $r7; + var $dvs; + var $rsize8; + var $p9; + var $r10; + $1=$bytes; + var $2=$1; //@line 4629 "/root/emscripten/system/lib/dlmalloc.c" + var $3=(($2)>>>0) <= 244; //@line 4629 "/root/emscripten/system/lib/dlmalloc.c" + if ($3) { __label__ = 3; break; } else { __label__ = 38; break; } //@line 4629 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $5=$1; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $6=(($5)>>>0) < 11; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + if ($6) { __label__ = 4; break; } else { __label__ = 5; break; } //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $14 = 16;__label__ = 6; break; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $9=$1; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $10=((($9)+(4))|0); //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $11=((($10)+(7))|0); //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $12=$11 & -8; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $14 = $12;__label__ = 6; break; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $14; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + $nb=$14; //@line 4632 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$nb; //@line 4633 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$15 >>> 3; //@line 4633 "/root/emscripten/system/lib/dlmalloc.c" + $idx=$16; //@line 4633 "/root/emscripten/system/lib/dlmalloc.c" + var $17=HEAP32[((((__gm_)|0))>>2)]; //@line 4634 "/root/emscripten/system/lib/dlmalloc.c" + var $18=$idx; //@line 4634 "/root/emscripten/system/lib/dlmalloc.c" + var $19=$17 >>> (($18)>>>0); //@line 4634 "/root/emscripten/system/lib/dlmalloc.c" + $smallbits=$19; //@line 4634 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$smallbits; //@line 4636 "/root/emscripten/system/lib/dlmalloc.c" + var $21=$20 & 3; //@line 4636 "/root/emscripten/system/lib/dlmalloc.c" + var $22=(($21)|0)!=0; //@line 4636 "/root/emscripten/system/lib/dlmalloc.c" + if ($22) { __label__ = 7; break; } else { __label__ = 14; break; } //@line 4636 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $24=$smallbits; //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$24 ^ -1; //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$25 & 1; //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$idx; //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + var $28=((($27)+($26))|0); //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + $idx=$28; //@line 4638 "/root/emscripten/system/lib/dlmalloc.c" + var $29=$idx; //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$29 << 1; //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + var $31=((((__gm_+40)|0)+($30<<2))|0); //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + var $32=$31; //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$32; //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + $b=$33; //@line 4639 "/root/emscripten/system/lib/dlmalloc.c" + var $34=$b; //@line 4640 "/root/emscripten/system/lib/dlmalloc.c" + var $35=(($34+8)|0); //@line 4640 "/root/emscripten/system/lib/dlmalloc.c" + var $36=HEAP32[(($35)>>2)]; //@line 4640 "/root/emscripten/system/lib/dlmalloc.c" + $p=$36; //@line 4640 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$p; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $38=(($37+8)|0); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $39=HEAP32[(($38)>>2)]; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + $F=$39; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$b; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$F; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $42=(($40)|0)==(($41)|0); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + if ($42) { __label__ = 8; break; } else { __label__ = 9; break; } //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $44=$idx; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $45=1 << $44; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $46=$45 ^ -1; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $47=HEAP32[((((__gm_)|0))>>2)]; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $48=$47 & $46; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$48; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 13; break; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $50=$F; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $51=$50; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $52=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $53=(($51)>>>0) >= (($52)>>>0); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $54=(($53)&1); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $55=(($54)==(1)); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $56=(($55)|0)!=0; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + if ($56) { __label__ = 10; break; } else { __label__ = 11; break; } //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $58=$F; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $59=$b; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $60=(($59+8)|0); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($60)>>2)]=$58; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $61=$b; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $62=$F; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + var $63=(($62+12)|0); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($63)>>2)]=$61; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 12; break; //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + _abort(); //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4642 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + __label__ = 13; break; + case 13: + var $67=$idx; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $68=$67 << 3; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $69=$68 | 1; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $70=$69 | 2; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $71=$p; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $72=(($71+4)|0); //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($72)>>2)]=$70; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $73=$p; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $74=$73; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $75=$idx; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $76=$75 << 3; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $77=(($74+$76)|0); //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $78=$77; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $79=(($78+4)|0); //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $80=HEAP32[(($79)>>2)]; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $81=$80 | 1; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($79)>>2)]=$81; //@line 4643 "/root/emscripten/system/lib/dlmalloc.c" + var $82=$p; //@line 4644 "/root/emscripten/system/lib/dlmalloc.c" + var $83=$82; //@line 4644 "/root/emscripten/system/lib/dlmalloc.c" + var $84=(($83+8)|0); //@line 4644 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$84; //@line 4644 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 54; break; //@line 4646 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $86=$nb; //@line 4649 "/root/emscripten/system/lib/dlmalloc.c" + var $87=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4649 "/root/emscripten/system/lib/dlmalloc.c" + var $88=(($86)>>>0) > (($87)>>>0); //@line 4649 "/root/emscripten/system/lib/dlmalloc.c" + if ($88) { __label__ = 15; break; } else { __label__ = 36; break; } //@line 4649 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $90=$smallbits; //@line 4650 "/root/emscripten/system/lib/dlmalloc.c" + var $91=(($90)|0)!=0; //@line 4650 "/root/emscripten/system/lib/dlmalloc.c" + if ($91) { __label__ = 16; break; } else { __label__ = 31; break; } //@line 4650 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + var $93=$smallbits; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $94=$idx; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $95=$93 << $94; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $96=$idx; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $97=1 << $96; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $98=$97 << 1; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $99=$idx; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $100=1 << $99; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$100 << 1; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $102=(((-$101))|0); //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $103=$98 | $102; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $104=$95 & $103; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + $leftbits=$104; //@line 4654 "/root/emscripten/system/lib/dlmalloc.c" + var $105=$leftbits; //@line 4655 "/root/emscripten/system/lib/dlmalloc.c" + var $106=$leftbits; //@line 4655 "/root/emscripten/system/lib/dlmalloc.c" + var $107=(((-$106))|0); //@line 4655 "/root/emscripten/system/lib/dlmalloc.c" + var $108=$105 & $107; //@line 4655 "/root/emscripten/system/lib/dlmalloc.c" + $leastbit=$108; //@line 4655 "/root/emscripten/system/lib/dlmalloc.c" + var $109=$leastbit; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $110=((($109)-(1))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$110; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $111=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $112=$111 >>> 12; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $113=$112 & 16; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $K=$113; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $114=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $N=$114; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $115=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $116=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $117=$116 >>> (($115)>>>0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$117; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $118=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $119=$118 >>> 5; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $120=$119 & 8; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $K=$120; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $121=$N; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $122=((($121)+($120))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $N=$122; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $123=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $124=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $125=$124 >>> (($123)>>>0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$125; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $126=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $127=$126 >>> 2; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $128=$127 & 4; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $K=$128; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $129=$N; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $130=((($129)+($128))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $N=$130; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $131=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $132=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $133=$132 >>> (($131)>>>0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$133; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $134=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $135=$134 >>> 1; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $136=$135 & 2; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $K=$136; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $137=$N; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $138=((($137)+($136))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $N=$138; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $139=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $140=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $141=$140 >>> (($139)>>>0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$141; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $142=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $143=$142 >>> 1; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $144=$143 & 1; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $K=$144; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $145=$N; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $146=((($145)+($144))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $N=$146; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $147=$K; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $148=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $149=$148 >>> (($147)>>>0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$149; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $150=$N; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $151=$Y; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $152=((($150)+($151))|0); //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + $i=$152; //@line 4656 "/root/emscripten/system/lib/dlmalloc.c" + var $153=$i; //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + var $154=$153 << 1; //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + var $155=((((__gm_+40)|0)+($154<<2))|0); //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + var $156=$155; //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + var $157=$156; //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + $b1=$157; //@line 4657 "/root/emscripten/system/lib/dlmalloc.c" + var $158=$b1; //@line 4658 "/root/emscripten/system/lib/dlmalloc.c" + var $159=(($158+8)|0); //@line 4658 "/root/emscripten/system/lib/dlmalloc.c" + var $160=HEAP32[(($159)>>2)]; //@line 4658 "/root/emscripten/system/lib/dlmalloc.c" + $p2=$160; //@line 4658 "/root/emscripten/system/lib/dlmalloc.c" + var $161=$p2; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $162=(($161+8)|0); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $163=HEAP32[(($162)>>2)]; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + $F3=$163; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $164=$b1; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $165=$F3; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $166=(($164)|0)==(($165)|0); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + if ($166) { __label__ = 17; break; } else { __label__ = 18; break; } //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $168=$i; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $169=1 << $168; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $170=$169 ^ -1; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $171=HEAP32[((((__gm_)|0))>>2)]; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $172=$171 & $170; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$172; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 22; break; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $174=$F3; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $175=$174; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $176=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $177=(($175)>>>0) >= (($176)>>>0); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $178=(($177)&1); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $179=(($178)==(1)); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $180=(($179)|0)!=0; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + if ($180) { __label__ = 19; break; } else { __label__ = 20; break; } //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $182=$F3; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $183=$b1; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $184=(($183+8)|0); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($184)>>2)]=$182; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $185=$b1; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $186=$F3; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + var $187=(($186+12)|0); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($187)>>2)]=$185; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 21; break; //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + _abort(); //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4660 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + __label__ = 22; break; + case 22: + var $191=$i; //@line 4661 "/root/emscripten/system/lib/dlmalloc.c" + var $192=$191 << 3; //@line 4661 "/root/emscripten/system/lib/dlmalloc.c" + var $193=$nb; //@line 4661 "/root/emscripten/system/lib/dlmalloc.c" + var $194=((($192)-($193))|0); //@line 4661 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$194; //@line 4661 "/root/emscripten/system/lib/dlmalloc.c" + var $195=$nb; //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + var $196=$195 | 1; //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + var $197=$196 | 2; //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + var $198=$p2; //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + var $199=(($198+4)|0); //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($199)>>2)]=$197; //@line 4666 "/root/emscripten/system/lib/dlmalloc.c" + var $200=$p2; //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + var $201=$200; //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + var $202=$nb; //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + var $203=(($201+$202)|0); //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + var $204=$203; //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + $r=$204; //@line 4667 "/root/emscripten/system/lib/dlmalloc.c" + var $205=$rsize; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $206=$205 | 1; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $207=$r; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $208=(($207+4)|0); //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($208)>>2)]=$206; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $209=$rsize; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $210=$r; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $211=$210; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $212=$rsize; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $213=(($211+$212)|0); //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $214=$213; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $215=(($214)|0); //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($215)>>2)]=$209; //@line 4668 "/root/emscripten/system/lib/dlmalloc.c" + var $216=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $DVS=$216; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $217=$DVS; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $218=(($217)|0)!=0; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + if ($218) { __label__ = 23; break; } else { __label__ = 30; break; } //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + var $220=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $DV=$220; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $221=$DVS; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $222=$221 >>> 3; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $I=$222; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $223=$I; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $224=$223 << 1; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $225=((((__gm_+40)|0)+($224<<2))|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $226=$225; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $227=$226; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $B=$227; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $228=$B; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $F4=$228; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $229=HEAP32[((((__gm_)|0))>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $230=$I; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $231=1 << $230; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $232=$229 & $231; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $233=(($232)|0)!=0; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + if ($233) { __label__ = 25; break; } else { __label__ = 24; break; } //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $235=$I; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $236=1 << $235; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $237=HEAP32[((((__gm_)|0))>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $238=$237 | $236; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$238; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 29; break; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $240=$B; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $241=(($240+8)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $242=HEAP32[(($241)>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $243=$242; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $244=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $245=(($243)>>>0) >= (($244)>>>0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $246=(($245)&1); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $247=(($246)==(1)); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($247)|0)!=0; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + if ($248) { __label__ = 26; break; } else { __label__ = 27; break; } //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $250=$B; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $251=(($250+8)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $252=HEAP32[(($251)>>2)]; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + $F4=$252; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 28; break; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + _abort(); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + __label__ = 29; break; + case 29: + var $256=$DV; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $257=$B; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $258=(($257+8)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($258)>>2)]=$256; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $259=$DV; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $260=$F4; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $261=(($260+12)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($261)>>2)]=$259; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $262=$F4; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $263=$DV; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $264=(($263+8)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($264)>>2)]=$262; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $265=$B; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $266=$DV; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $267=(($266+12)|0); //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($267)>>2)]=$265; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 30; break; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $269=$rsize; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=$269; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $270=$r; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+20)|0))>>2)]=$270; //@line 4669 "/root/emscripten/system/lib/dlmalloc.c" + var $271=$p2; //@line 4671 "/root/emscripten/system/lib/dlmalloc.c" + var $272=$271; //@line 4671 "/root/emscripten/system/lib/dlmalloc.c" + var $273=(($272+8)|0); //@line 4671 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$273; //@line 4671 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 54; break; //@line 4673 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $275=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($275)|0)!=0; //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + if ($276) { __label__ = 32; break; } else { __label__ = 34; break; } //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $278=$nb; //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + var $279=_tmalloc_small(__gm_, $278); //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$279; //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + var $280=(($279)|0)!=0; //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + if ($280) { __label__ = 33; break; } else { __label__ = 34; break; } //@line 4676 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + __label__ = 54; break; //@line 4678 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + __label__ = 35; break; + case 35: + __label__ = 36; break; //@line 4680 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + __label__ = 37; break; + case 37: + __label__ = 45; break; //@line 4681 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $287=$1; //@line 4682 "/root/emscripten/system/lib/dlmalloc.c" + var $288=(($287)>>>0) >= 4294967232; //@line 4682 "/root/emscripten/system/lib/dlmalloc.c" + if ($288) { __label__ = 39; break; } else { __label__ = 40; break; } //@line 4682 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + $nb=-1; //@line 4683 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 44; break; //@line 4683 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + var $291=$1; //@line 4685 "/root/emscripten/system/lib/dlmalloc.c" + var $292=((($291)+(4))|0); //@line 4685 "/root/emscripten/system/lib/dlmalloc.c" + var $293=((($292)+(7))|0); //@line 4685 "/root/emscripten/system/lib/dlmalloc.c" + var $294=$293 & -8; //@line 4685 "/root/emscripten/system/lib/dlmalloc.c" + $nb=$294; //@line 4685 "/root/emscripten/system/lib/dlmalloc.c" + var $295=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + var $296=(($295)|0)!=0; //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + if ($296) { __label__ = 41; break; } else { __label__ = 43; break; } //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + case 41: + var $298=$nb; //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + var $299=_tmalloc_large(__gm_, $298); //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$299; //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + var $300=(($299)|0)!=0; //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + if ($300) { __label__ = 42; break; } else { __label__ = 43; break; } //@line 4686 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + __label__ = 54; break; //@line 4688 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + __label__ = 44; break; + case 44: + __label__ = 45; break; + case 45: + var $305=$nb; //@line 4692 "/root/emscripten/system/lib/dlmalloc.c" + var $306=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4692 "/root/emscripten/system/lib/dlmalloc.c" + var $307=(($305)>>>0) <= (($306)>>>0); //@line 4692 "/root/emscripten/system/lib/dlmalloc.c" + if ($307) { __label__ = 46; break; } else { __label__ = 50; break; } //@line 4692 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $309=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4693 "/root/emscripten/system/lib/dlmalloc.c" + var $310=$nb; //@line 4693 "/root/emscripten/system/lib/dlmalloc.c" + var $311=((($309)-($310))|0); //@line 4693 "/root/emscripten/system/lib/dlmalloc.c" + $rsize5=$311; //@line 4693 "/root/emscripten/system/lib/dlmalloc.c" + var $312=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4694 "/root/emscripten/system/lib/dlmalloc.c" + $p6=$312; //@line 4694 "/root/emscripten/system/lib/dlmalloc.c" + var $313=$rsize5; //@line 4695 "/root/emscripten/system/lib/dlmalloc.c" + var $314=(($313)>>>0) >= 16; //@line 4695 "/root/emscripten/system/lib/dlmalloc.c" + if ($314) { __label__ = 47; break; } else { __label__ = 48; break; } //@line 4695 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + var $316=$p6; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + var $317=$316; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + var $318=$nb; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + var $319=(($317+$318)|0); //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + var $320=$319; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+20)|0))>>2)]=$320; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + $r7=$320; //@line 4696 "/root/emscripten/system/lib/dlmalloc.c" + var $321=$rsize5; //@line 4697 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=$321; //@line 4697 "/root/emscripten/system/lib/dlmalloc.c" + var $322=$rsize5; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $323=$322 | 1; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $324=$r7; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $325=(($324+4)|0); //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($325)>>2)]=$323; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $326=$rsize5; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $327=$r7; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $328=$327; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $329=$rsize5; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $330=(($328+$329)|0); //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $331=$330; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $332=(($331)|0); //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($332)>>2)]=$326; //@line 4698 "/root/emscripten/system/lib/dlmalloc.c" + var $333=$nb; //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + var $334=$333 | 1; //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + var $335=$334 | 2; //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + var $336=$p6; //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + var $337=(($336+4)|0); //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($337)>>2)]=$335; //@line 4699 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 49; break; //@line 4700 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + var $339=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4702 "/root/emscripten/system/lib/dlmalloc.c" + $dvs=$339; //@line 4702 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=0; //@line 4703 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+20)|0))>>2)]=0; //@line 4704 "/root/emscripten/system/lib/dlmalloc.c" + var $340=$dvs; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $341=$340 | 1; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $342=$341 | 2; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $343=$p6; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $344=(($343+4)|0); //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($344)>>2)]=$342; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $345=$p6; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $346=$345; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $347=$dvs; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $348=(($346+$347)|0); //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $349=$348; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $350=(($349+4)|0); //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $351=HEAP32[(($350)>>2)]; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + var $352=$351 | 1; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($350)>>2)]=$352; //@line 4705 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 49; break; + case 49: + var $354=$p6; //@line 4707 "/root/emscripten/system/lib/dlmalloc.c" + var $355=$354; //@line 4707 "/root/emscripten/system/lib/dlmalloc.c" + var $356=(($355+8)|0); //@line 4707 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$356; //@line 4707 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 54; break; //@line 4709 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + var $358=$nb; //@line 4712 "/root/emscripten/system/lib/dlmalloc.c" + var $359=HEAP32[((((__gm_+12)|0))>>2)]; //@line 4712 "/root/emscripten/system/lib/dlmalloc.c" + var $360=(($358)>>>0) < (($359)>>>0); //@line 4712 "/root/emscripten/system/lib/dlmalloc.c" + if ($360) { __label__ = 51; break; } else { __label__ = 52; break; } //@line 4712 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + var $362=$nb; //@line 4713 "/root/emscripten/system/lib/dlmalloc.c" + var $363=HEAP32[((((__gm_+12)|0))>>2)]; //@line 4713 "/root/emscripten/system/lib/dlmalloc.c" + var $364=((($363)-($362))|0); //@line 4713 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+12)|0))>>2)]=$364; //@line 4713 "/root/emscripten/system/lib/dlmalloc.c" + $rsize8=$364; //@line 4713 "/root/emscripten/system/lib/dlmalloc.c" + var $365=HEAP32[((((__gm_+24)|0))>>2)]; //@line 4714 "/root/emscripten/system/lib/dlmalloc.c" + $p9=$365; //@line 4714 "/root/emscripten/system/lib/dlmalloc.c" + var $366=$p9; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + var $367=$366; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$nb; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + var $369=(($367+$368)|0); //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + var $370=$369; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+24)|0))>>2)]=$370; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + $r10=$370; //@line 4715 "/root/emscripten/system/lib/dlmalloc.c" + var $371=$rsize8; //@line 4716 "/root/emscripten/system/lib/dlmalloc.c" + var $372=$371 | 1; //@line 4716 "/root/emscripten/system/lib/dlmalloc.c" + var $373=$r10; //@line 4716 "/root/emscripten/system/lib/dlmalloc.c" + var $374=(($373+4)|0); //@line 4716 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($374)>>2)]=$372; //@line 4716 "/root/emscripten/system/lib/dlmalloc.c" + var $375=$nb; //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + var $376=$375 | 1; //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + var $377=$376 | 2; //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + var $378=$p9; //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + var $379=(($378+4)|0); //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($379)>>2)]=$377; //@line 4717 "/root/emscripten/system/lib/dlmalloc.c" + var $380=$p9; //@line 4718 "/root/emscripten/system/lib/dlmalloc.c" + var $381=$380; //@line 4718 "/root/emscripten/system/lib/dlmalloc.c" + var $382=(($381+8)|0); //@line 4718 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$382; //@line 4718 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 54; break; //@line 4721 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + __label__ = 53; break; + case 53: + var $385=$nb; //@line 4724 "/root/emscripten/system/lib/dlmalloc.c" + var $386=_sys_alloc(__gm_, $385); //@line 4724 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$386; //@line 4724 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 54; break; //@line 4724 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + var $388=$mem; //@line 4728 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $388; //@line 4728 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +Module["_malloc"] = _malloc;_malloc["X"]=1; + +function _tmalloc_small($m, $nb) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $t; + var $v; + var $rsize; + var $i; + var $leastbit; + var $Y; + var $K; + var $N; + var $trem; + var $r; + var $XP; + var $R; + var $F; + var $RP; + var $CP; + var $H; + var $C0; + var $C1; + var $DVS; + var $DV; + var $I; + var $B; + var $F1; + $1=$m; + $2=$nb; + var $3=$1; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $4=(($3+4)|0); //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $5=HEAP32[(($4)>>2)]; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $6=$1; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $7=(($6+4)|0); //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $8=HEAP32[(($7)>>2)]; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(((-$8))|0); //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $10=$5 & $9; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + $leastbit=$10; //@line 4269 "/root/emscripten/system/lib/dlmalloc.c" + var $11=$leastbit; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $12=((($11)-(1))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$12; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $13=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $14=$13 >>> 12; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$14 & 16; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $K=$15; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $N=$16; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $17=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $18=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $19=$18 >>> (($17)>>>0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$19; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $21=$20 >>> 5; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $22=$21 & 8; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $K=$22; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$N; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $24=((($23)+($22))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $N=$24; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$26 >>> (($25)>>>0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$27; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $29=$28 >>> 2; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$29 & 4; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $K=$30; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $31=$N; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $32=((($31)+($30))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $N=$32; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $34=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $35=$34 >>> (($33)>>>0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$35; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$36 >>> 1; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $38=$37 & 2; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $K=$38; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $39=$N; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $40=((($39)+($38))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $N=$40; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$42 >>> (($41)>>>0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$43; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $44=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$44 >>> 1; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $46=$45 & 1; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $K=$46; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $47=$N; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $48=((($47)+($46))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $N=$48; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $49=$K; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $51=$50 >>> (($49)>>>0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$51; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $52=$N; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $53=$Y; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $54=((($52)+($53))|0); //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + $i=$54; //@line 4270 "/root/emscripten/system/lib/dlmalloc.c" + var $55=$i; //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$1; //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56+304)|0); //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + var $58=(($57+($55<<2))|0); //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + var $59=HEAP32[(($58)>>2)]; //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + $t=$59; //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + $v=$59; //@line 4271 "/root/emscripten/system/lib/dlmalloc.c" + var $60=$t; //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + var $61=(($60+4)|0); //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + var $62=HEAP32[(($61)>>2)]; //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$62 & -8; //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + var $64=$2; //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + var $65=((($63)-($64))|0); //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$65; //@line 4272 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $67=$t; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $68=(($67+16)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $69=(($68)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $70=HEAP32[(($69)>>2)]; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $71=(($70)|0)!=0; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + if ($71) { __label__ = 4; break; } else { __label__ = 5; break; } //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $73=$t; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $74=(($73+16)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $75=(($74)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $76=HEAP32[(($75)>>2)]; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $83 = $76;__label__ = 6; break; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $78=$t; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $79=(($78+16)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $80=(($79+4)|0); //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $81=HEAP32[(($80)>>2)]; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $83 = $81;__label__ = 6; break; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $83; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + $t=$83; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + var $84=(($83)|0)!=0; //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + if ($84) { __label__ = 7; break; } else { __label__ = 10; break; } //@line 4274 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $86=$t; //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $87=(($86+4)|0); //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $88=HEAP32[(($87)>>2)]; //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $89=$88 & -8; //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $90=$2; //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $91=((($89)-($90))|0); //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + $trem=$91; //@line 4275 "/root/emscripten/system/lib/dlmalloc.c" + var $92=$trem; //@line 4276 "/root/emscripten/system/lib/dlmalloc.c" + var $93=$rsize; //@line 4276 "/root/emscripten/system/lib/dlmalloc.c" + var $94=(($92)>>>0) < (($93)>>>0); //@line 4276 "/root/emscripten/system/lib/dlmalloc.c" + if ($94) { __label__ = 8; break; } else { __label__ = 9; break; } //@line 4276 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $96=$trem; //@line 4277 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$96; //@line 4277 "/root/emscripten/system/lib/dlmalloc.c" + var $97=$t; //@line 4278 "/root/emscripten/system/lib/dlmalloc.c" + $v=$97; //@line 4278 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 9; break; //@line 4279 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + __label__ = 3; break; //@line 4280 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $100=$v; //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$100; //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $102=$1; //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $103=(($102+16)|0); //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $104=HEAP32[(($103)>>2)]; //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $105=(($101)>>>0) >= (($104)>>>0); //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $106=(($105)&1); //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $107=(($106)==(1)); //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + var $108=(($107)|0)!=0; //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + if ($108) { __label__ = 11; break; } else { __label__ = 70; break; } //@line 4282 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $110=$v; //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + var $111=$110; //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + var $112=$2; //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + var $113=(($111+$112)|0); //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + var $114=$113; //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + $r=$114; //@line 4283 "/root/emscripten/system/lib/dlmalloc.c" + var $115=$v; //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $116=$115; //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $117=$r; //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $118=$117; //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $119=(($116)>>>0) < (($118)>>>0); //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $120=(($119)&1); //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $121=(($120)==(1)); //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + var $122=(($121)|0)!=0; //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + if ($122) { __label__ = 12; break; } else { __label__ = 69; break; } //@line 4285 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $124=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $125=(($124+24)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $126=HEAP32[(($125)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $XP=$126; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $127=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $128=(($127+12)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $129=HEAP32[(($128)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $130=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $131=(($129)|0)!=(($130)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($131) { __label__ = 13; break; } else { __label__ = 17; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $133=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $134=(($133+8)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $135=HEAP32[(($134)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $F=$135; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $136=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $137=(($136+12)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $138=HEAP32[(($137)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $R=$138; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $139=$F; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $140=$139; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $141=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $142=(($141+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $143=HEAP32[(($142)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $144=(($140)>>>0) >= (($143)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $145=(($144)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $146=(($145)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $147=(($146)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($147) { __label__ = 14; break; } else { __label__ = 15; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $149=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $150=$F; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $151=(($150+12)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($151)>>2)]=$149; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $152=$F; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $153=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $154=(($153+8)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($154)>>2)]=$152; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 16; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + __label__ = 29; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $158=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $159=(($158+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $160=(($159+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$160; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $161=HEAP32[(($160)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $R=$161; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $162=(($161)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($162) { __label__ = 19; break; } else { __label__ = 18; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $164=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $165=(($164+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $166=(($165)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$166; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $167=HEAP32[(($166)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $R=$167; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $168=(($167)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($168) { __label__ = 19; break; } else { __label__ = 28; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + __label__ = 20; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + var $171=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $172=(($171+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $173=(($172+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$173; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $174=HEAP32[(($173)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $175=(($174)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($175) { var $183 = 1;__label__ = 22; break; } else { __label__ = 21; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + var $177=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $178=(($177+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $179=(($178)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$179; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $180=HEAP32[(($179)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $181=(($180)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $183 = $181;__label__ = 22; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + var $183; + if ($183) { __label__ = 23; break; } else { __label__ = 24; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + var $185=$CP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$185; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $186=HEAP32[(($185)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $R=$186; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 20; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $188=$RP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $189=$188; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $190=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $191=(($190+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $192=HEAP32[(($191)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $193=(($189)>>>0) >= (($192)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $194=(($193)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $195=(($194)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $196=(($195)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($196) { __label__ = 25; break; } else { __label__ = 26; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $198=$RP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($198)>>2)]=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 27; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + __label__ = 28; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + __label__ = 29; break; + case 29: + var $203=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $204=(($203)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($204) { __label__ = 30; break; } else { __label__ = 57; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $206=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $207=(($206+28)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $208=HEAP32[(($207)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $209=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $210=(($209+304)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $211=(($210+($208<<2))|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $H=$211; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $212=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $213=$H; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $214=HEAP32[(($213)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $215=(($212)|0)==(($214)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($215) { __label__ = 31; break; } else { __label__ = 34; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $217=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $218=$H; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($218)>>2)]=$217; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $219=(($217)|0)==0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($219) { __label__ = 32; break; } else { __label__ = 33; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $221=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $222=(($221+28)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $223=HEAP32[(($222)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $224=1 << $223; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $225=$224 ^ -1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $226=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $227=(($226+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $228=HEAP32[(($227)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $229=$228 & $225; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($227)>>2)]=$229; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 33; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + __label__ = 41; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $232=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $233=$232; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $234=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $235=(($234+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $236=HEAP32[(($235)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $237=(($233)>>>0) >= (($236)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $238=(($237)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $239=(($238)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $240=(($239)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($240) { __label__ = 35; break; } else { __label__ = 39; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $242=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $243=(($242+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $244=(($243)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $245=HEAP32[(($244)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $246=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $247=(($245)|0)==(($246)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($247) { __label__ = 36; break; } else { __label__ = 37; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $249=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $250=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $251=(($250+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $252=(($251)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($252)>>2)]=$249; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 38; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $254=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $255=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $256=(($255+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $257=(($256+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($257)>>2)]=$254; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 38; break; + case 38: + __label__ = 40; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + __label__ = 41; break; + case 41: + var $262=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $263=(($262)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($263) { __label__ = 42; break; } else { __label__ = 56; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + var $265=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $266=$265; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $267=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $268=(($267+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $269=HEAP32[(($268)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $270=(($266)>>>0) >= (($269)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $271=(($270)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $272=(($271)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $273=(($272)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($273) { __label__ = 43; break; } else { __label__ = 54; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + var $275=$XP; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $276=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $277=(($276+24)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($277)>>2)]=$275; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $278=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $279=(($278+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $280=(($279)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $281=HEAP32[(($280)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $C0=$281; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $282=(($281)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($282) { __label__ = 44; break; } else { __label__ = 48; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + var $284=$C0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $285=$284; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $286=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $287=(($286+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $288=HEAP32[(($287)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $289=(($285)>>>0) >= (($288)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $290=(($289)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $291=(($290)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $292=(($291)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($292) { __label__ = 45; break; } else { __label__ = 46; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + var $294=$C0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $295=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $296=(($295+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $297=(($296)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($297)>>2)]=$294; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $298=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $299=$C0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $300=(($299+24)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($300)>>2)]=$298; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 47; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + __label__ = 48; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + var $304=$v; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $305=(($304+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $306=(($305+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $307=HEAP32[(($306)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + $C1=$307; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $308=(($307)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($308) { __label__ = 49; break; } else { __label__ = 53; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $310=$C1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $311=$310; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $312=$1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $313=(($312+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $314=HEAP32[(($313)>>2)]; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $315=(($311)>>>0) >= (($314)>>>0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $316=(($315)&1); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $317=(($316)==(1)); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $318=(($317)|0)!=0; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + if ($318) { __label__ = 50; break; } else { __label__ = 51; break; } //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + var $320=$C1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $321=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $322=(($321+16)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $323=(($322+4)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($323)>>2)]=$320; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $324=$R; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $325=$C1; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + var $326=(($325+24)|0); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($326)>>2)]=$324; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 52; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + __label__ = 53; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 53: + __label__ = 55; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + _abort(); //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 55: + __label__ = 56; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + __label__ = 57; break; //@line 4286 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + var $334=$rsize; //@line 4287 "/root/emscripten/system/lib/dlmalloc.c" + var $335=(($334)>>>0) < 16; //@line 4287 "/root/emscripten/system/lib/dlmalloc.c" + if ($335) { __label__ = 58; break; } else { __label__ = 59; break; } //@line 4287 "/root/emscripten/system/lib/dlmalloc.c" + case 58: + var $337=$rsize; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $338=$2; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $339=((($337)+($338))|0); //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $340=$339 | 1; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $341=$340 | 2; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $342=$v; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $343=(($342+4)|0); //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($343)>>2)]=$341; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $344=$v; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $345=$344; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $346=$rsize; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $347=$2; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $348=((($346)+($347))|0); //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $349=(($345+$348)|0); //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $350=$349; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $351=(($350+4)|0); //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $352=HEAP32[(($351)>>2)]; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + var $353=$352 | 1; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($351)>>2)]=$353; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 68; break; //@line 4288 "/root/emscripten/system/lib/dlmalloc.c" + case 59: + var $355=$2; //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + var $356=$355 | 1; //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + var $357=$356 | 2; //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + var $358=$v; //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + var $359=(($358+4)|0); //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($359)>>2)]=$357; //@line 4290 "/root/emscripten/system/lib/dlmalloc.c" + var $360=$rsize; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $361=$360 | 1; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $362=$r; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $363=(($362+4)|0); //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($363)>>2)]=$361; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $364=$rsize; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $365=$r; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $366=$365; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $367=$rsize; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $368=(($366+$367)|0); //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $369=$368; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $370=(($369)|0); //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($370)>>2)]=$364; //@line 4291 "/root/emscripten/system/lib/dlmalloc.c" + var $371=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $372=(($371+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $373=HEAP32[(($372)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $DVS=$373; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $374=$DVS; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $375=(($374)|0)!=0; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + if ($375) { __label__ = 60; break; } else { __label__ = 67; break; } //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + var $377=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $378=(($377+20)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $379=HEAP32[(($378)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $DV=$379; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $380=$DVS; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $381=$380 >>> 3; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $I=$381; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $382=$I; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $383=$382 << 1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $384=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $385=(($384+40)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $386=(($385+($383<<2))|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $387=$386; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $388=$387; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $B=$388; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $389=$B; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $F1=$389; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $390=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $391=(($390)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $392=HEAP32[(($391)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $393=$I; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $394=1 << $393; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $395=$392 & $394; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $396=(($395)|0)!=0; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + if ($396) { __label__ = 62; break; } else { __label__ = 61; break; } //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + var $398=$I; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $399=1 << $398; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $400=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $401=(($400)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $402=HEAP32[(($401)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $403=$402 | $399; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($401)>>2)]=$403; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 66; break; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + var $405=$B; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $406=(($405+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $407=HEAP32[(($406)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $408=$407; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $409=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $410=(($409+16)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $411=HEAP32[(($410)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $412=(($408)>>>0) >= (($411)>>>0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $413=(($412)&1); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $414=(($413)==(1)); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $415=(($414)|0)!=0; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + if ($415) { __label__ = 63; break; } else { __label__ = 64; break; } //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 63: + var $417=$B; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $418=(($417+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $419=HEAP32[(($418)>>2)]; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + $F1=$419; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 65; break; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 64: + _abort(); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 65: + __label__ = 66; break; + case 66: + var $423=$DV; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $424=$B; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $425=(($424+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($425)>>2)]=$423; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $426=$DV; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $427=$F1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $428=(($427+12)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($428)>>2)]=$426; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $429=$F1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $430=$DV; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $431=(($430+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($431)>>2)]=$429; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $432=$B; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $433=$DV; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $434=(($433+12)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($434)>>2)]=$432; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 67; break; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + case 67: + var $436=$rsize; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $437=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $438=(($437+8)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($438)>>2)]=$436; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $439=$r; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $440=$1; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + var $441=(($440+20)|0); //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($441)>>2)]=$439; //@line 4292 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 68; break; + case 68: + var $443=$v; //@line 4294 "/root/emscripten/system/lib/dlmalloc.c" + var $444=$443; //@line 4294 "/root/emscripten/system/lib/dlmalloc.c" + var $445=(($444+8)|0); //@line 4294 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $445; //@line 4294 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + __label__ = 70; break; //@line 4296 "/root/emscripten/system/lib/dlmalloc.c" + case 70: + _abort(); //@line 4298 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4298 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_tmalloc_small["X"]=1; + +function _tmalloc_large($m, $nb) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $v; + var $rsize; + var $t; + var $idx; + var $X; + var $Y; + var $N; + var $K; + var $sizebits; + var $rst; + var $rt; + var $trem; + var $leftbits; + var $i; + var $leastbit; + var $Y1; + var $K2; + var $N3; + var $trem4; + var $r; + var $XP; + var $R; + var $F; + var $RP; + var $CP; + var $H; + var $C0; + var $C1; + var $I; + var $B; + var $F5; + var $TP; + var $H6; + var $I7; + var $X8; + var $Y9; + var $N10; + var $K11; + var $T; + var $K12; + var $C; + var $F13; + $2=$m; + $3=$nb; + $v=0; //@line 4195 "/root/emscripten/system/lib/dlmalloc.c" + var $4=$3; //@line 4196 "/root/emscripten/system/lib/dlmalloc.c" + var $5=(((-$4))|0); //@line 4196 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$5; //@line 4196 "/root/emscripten/system/lib/dlmalloc.c" + var $6=$3; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $7=$6 >>> 8; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $X=$7; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$X; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(($8)|0)==0; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + $idx=0; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 8; break; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $12=$X; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $13=(($12)>>>0) > 65535; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + if ($13) { __label__ = 5; break; } else { __label__ = 6; break; } //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + $idx=31; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 7; break; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $16=$X; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$16; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $17=$Y; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $18=((($17)-(256))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $19=$18 >>> 16; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$19 & 8; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $N=$20; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $21=$N; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $22=$Y; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$22 << $21; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$23; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $24=((($23)-(4096))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$24 >>> 16; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$25 & 4; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $K=$26; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$K; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$N; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $29=((($28)+($27))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $N=$29; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$K; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $31=$Y; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $32=$31 << $30; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$32; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $33=((($32)-(16384))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $34=$33 >>> 16; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $35=$34 & 2; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $K=$35; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$N; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $37=((($36)+($35))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $N=$37; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $38=$N; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $39=(((14)-($38))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$K; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$Y; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$41 << $40; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$42; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$42 >>> 15; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $44=((($39)+($43))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $K=$44; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$K; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $46=$45 << 1; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $47=$3; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $48=$K; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $49=((($48)+(7))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$47 >>> (($49)>>>0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $51=$50 & 1; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + var $52=((($46)+($51))|0); //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + $idx=$52; //@line 4199 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 7; break; + case 7: + __label__ = 8; break; + case 8: + var $55=$idx; //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$2; //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56+304)|0); //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + var $58=(($57+($55<<2))|0); //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + var $59=HEAP32[(($58)>>2)]; //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + $t=$59; //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + var $60=(($59)|0)!=0; //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + if ($60) { __label__ = 9; break; } else { __label__ = 24; break; } //@line 4200 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $62=$3; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$idx; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $64=(($63)|0)==31; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + if ($64) { __label__ = 10; break; } else { __label__ = 11; break; } //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $73 = 0;__label__ = 12; break; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $67=$idx; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $68=$67 >>> 1; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $69=((($68)+(8))|0); //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $70=((($69)-(2))|0); //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $71=(((31)-($70))|0); //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $73 = $71;__label__ = 12; break; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $73; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + var $74=$62 << $73; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + $sizebits=$74; //@line 4202 "/root/emscripten/system/lib/dlmalloc.c" + $rst=0; //@line 4203 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 13; break; //@line 4204 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $76=$t; //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $77=(($76+4)|0); //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $78=HEAP32[(($77)>>2)]; //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $79=$78 & -8; //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $80=$3; //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $81=((($79)-($80))|0); //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + $trem=$81; //@line 4206 "/root/emscripten/system/lib/dlmalloc.c" + var $82=$trem; //@line 4207 "/root/emscripten/system/lib/dlmalloc.c" + var $83=$rsize; //@line 4207 "/root/emscripten/system/lib/dlmalloc.c" + var $84=(($82)>>>0) < (($83)>>>0); //@line 4207 "/root/emscripten/system/lib/dlmalloc.c" + if ($84) { __label__ = 14; break; } else { __label__ = 17; break; } //@line 4207 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $86=$t; //@line 4208 "/root/emscripten/system/lib/dlmalloc.c" + $v=$86; //@line 4208 "/root/emscripten/system/lib/dlmalloc.c" + var $87=$trem; //@line 4209 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$87; //@line 4209 "/root/emscripten/system/lib/dlmalloc.c" + var $88=(($87)|0)==0; //@line 4209 "/root/emscripten/system/lib/dlmalloc.c" + if ($88) { __label__ = 15; break; } else { __label__ = 16; break; } //@line 4209 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + __label__ = 23; break; //@line 4210 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + __label__ = 17; break; //@line 4211 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $92=$t; //@line 4212 "/root/emscripten/system/lib/dlmalloc.c" + var $93=(($92+16)|0); //@line 4212 "/root/emscripten/system/lib/dlmalloc.c" + var $94=(($93+4)|0); //@line 4212 "/root/emscripten/system/lib/dlmalloc.c" + var $95=HEAP32[(($94)>>2)]; //@line 4212 "/root/emscripten/system/lib/dlmalloc.c" + $rt=$95; //@line 4212 "/root/emscripten/system/lib/dlmalloc.c" + var $96=$sizebits; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $97=$96 >>> 31; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $98=$97 & 1; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $99=$t; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $100=(($99+16)|0); //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $101=(($100+($98<<2))|0); //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $102=HEAP32[(($101)>>2)]; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + $t=$102; //@line 4213 "/root/emscripten/system/lib/dlmalloc.c" + var $103=$rt; //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + var $104=(($103)|0)!=0; //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + if ($104) { __label__ = 18; break; } else { __label__ = 20; break; } //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $106=$rt; //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + var $107=$t; //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + var $108=(($106)|0)!=(($107)|0); //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + if ($108) { __label__ = 19; break; } else { __label__ = 20; break; } //@line 4214 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $110=$rt; //@line 4215 "/root/emscripten/system/lib/dlmalloc.c" + $rst=$110; //@line 4215 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 20; break; //@line 4215 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + var $112=$t; //@line 4216 "/root/emscripten/system/lib/dlmalloc.c" + var $113=(($112)|0)==0; //@line 4216 "/root/emscripten/system/lib/dlmalloc.c" + if ($113) { __label__ = 21; break; } else { __label__ = 22; break; } //@line 4216 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + var $115=$rst; //@line 4217 "/root/emscripten/system/lib/dlmalloc.c" + $t=$115; //@line 4217 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 23; break; //@line 4218 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + var $117=$sizebits; //@line 4220 "/root/emscripten/system/lib/dlmalloc.c" + var $118=$117 << 1; //@line 4220 "/root/emscripten/system/lib/dlmalloc.c" + $sizebits=$118; //@line 4220 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 13; break; //@line 4221 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + __label__ = 24; break; //@line 4222 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $121=$t; //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + var $122=(($121)|0)==0; //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + if ($122) { __label__ = 25; break; } else { __label__ = 29; break; } //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $124=$v; //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + var $125=(($124)|0)==0; //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + if ($125) { __label__ = 26; break; } else { __label__ = 29; break; } //@line 4223 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $127=$idx; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $128=1 << $127; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $129=$128 << 1; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $130=$idx; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $131=1 << $130; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $132=$131 << 1; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $133=(((-$132))|0); //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $134=$129 | $133; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $135=$2; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $136=(($135+4)|0); //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $137=HEAP32[(($136)>>2)]; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $138=$134 & $137; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + $leftbits=$138; //@line 4224 "/root/emscripten/system/lib/dlmalloc.c" + var $139=$leftbits; //@line 4225 "/root/emscripten/system/lib/dlmalloc.c" + var $140=(($139)|0)!=0; //@line 4225 "/root/emscripten/system/lib/dlmalloc.c" + if ($140) { __label__ = 27; break; } else { __label__ = 28; break; } //@line 4225 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + var $142=$leftbits; //@line 4227 "/root/emscripten/system/lib/dlmalloc.c" + var $143=$leftbits; //@line 4227 "/root/emscripten/system/lib/dlmalloc.c" + var $144=(((-$143))|0); //@line 4227 "/root/emscripten/system/lib/dlmalloc.c" + var $145=$142 & $144; //@line 4227 "/root/emscripten/system/lib/dlmalloc.c" + $leastbit=$145; //@line 4227 "/root/emscripten/system/lib/dlmalloc.c" + var $146=$leastbit; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $147=((($146)-(1))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$147; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $148=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $149=$148 >>> 12; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $150=$149 & 16; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$150; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $151=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $N3=$151; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $152=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $153=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $154=$153 >>> (($152)>>>0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$154; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $155=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $156=$155 >>> 5; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $157=$156 & 8; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$157; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $158=$N3; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $159=((($158)+($157))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $N3=$159; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $160=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $161=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $162=$161 >>> (($160)>>>0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$162; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $163=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $164=$163 >>> 2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $165=$164 & 4; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$165; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $166=$N3; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $167=((($166)+($165))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $N3=$167; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $168=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $169=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $170=$169 >>> (($168)>>>0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$170; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $171=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $172=$171 >>> 1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $173=$172 & 2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$173; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $174=$N3; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $175=((($174)+($173))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $N3=$175; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $176=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $177=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $178=$177 >>> (($176)>>>0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$178; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $179=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $180=$179 >>> 1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $181=$180 & 1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$181; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $182=$N3; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $183=((($182)+($181))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $N3=$183; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $184=$K2; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $185=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $186=$185 >>> (($184)>>>0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $Y1=$186; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $187=$N3; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $188=$Y1; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $189=((($187)+($188))|0); //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + $i=$189; //@line 4228 "/root/emscripten/system/lib/dlmalloc.c" + var $190=$i; //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + var $191=$2; //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + var $192=(($191+304)|0); //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + var $193=(($192+($190<<2))|0); //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + var $194=HEAP32[(($193)>>2)]; //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + $t=$194; //@line 4229 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 28; break; //@line 4230 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + __label__ = 29; break; //@line 4231 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + __label__ = 30; break; //@line 4233 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $198=$t; //@line 4233 "/root/emscripten/system/lib/dlmalloc.c" + var $199=(($198)|0)!=0; //@line 4233 "/root/emscripten/system/lib/dlmalloc.c" + if ($199) { __label__ = 31; break; } else { __label__ = 37; break; } //@line 4233 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $201=$t; //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $202=(($201+4)|0); //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $203=HEAP32[(($202)>>2)]; //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $204=$203 & -8; //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $205=$3; //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $206=((($204)-($205))|0); //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + $trem4=$206; //@line 4234 "/root/emscripten/system/lib/dlmalloc.c" + var $207=$trem4; //@line 4235 "/root/emscripten/system/lib/dlmalloc.c" + var $208=$rsize; //@line 4235 "/root/emscripten/system/lib/dlmalloc.c" + var $209=(($207)>>>0) < (($208)>>>0); //@line 4235 "/root/emscripten/system/lib/dlmalloc.c" + if ($209) { __label__ = 32; break; } else { __label__ = 33; break; } //@line 4235 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $211=$trem4; //@line 4236 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$211; //@line 4236 "/root/emscripten/system/lib/dlmalloc.c" + var $212=$t; //@line 4237 "/root/emscripten/system/lib/dlmalloc.c" + $v=$212; //@line 4237 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 33; break; //@line 4238 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + var $214=$t; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $215=(($214+16)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $216=(($215)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $217=HEAP32[(($216)>>2)]; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $218=(($217)|0)!=0; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + if ($218) { __label__ = 34; break; } else { __label__ = 35; break; } //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $220=$t; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $221=(($220+16)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $222=(($221)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $223=HEAP32[(($222)>>2)]; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $230 = $223;__label__ = 36; break; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $225=$t; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $226=(($225+16)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $227=(($226+4)|0); //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $228=HEAP32[(($227)>>2)]; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + var $230 = $228;__label__ = 36; break; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $230; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + $t=$230; //@line 4239 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 30; break; //@line 4240 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $232=$v; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $233=(($232)|0)!=0; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + if ($233) { __label__ = 38; break; } else { __label__ = 127; break; } //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $235=$rsize; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $236=$2; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $237=(($236+8)|0); //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $238=HEAP32[(($237)>>2)]; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $239=$3; //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $240=((($238)-($239))|0); //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + var $241=(($235)>>>0) < (($240)>>>0); //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + if ($241) { __label__ = 39; break; } else { __label__ = 127; break; } //@line 4243 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + var $243=$v; //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $244=$243; //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $245=$2; //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $246=(($245+16)|0); //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $247=HEAP32[(($246)>>2)]; //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($244)>>>0) >= (($247)>>>0); //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $249=(($248)&1); //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $250=(($249)==(1)); //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + var $251=(($250)|0)!=0; //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + if ($251) { __label__ = 40; break; } else { __label__ = 126; break; } //@line 4244 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + var $253=$v; //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + var $254=$253; //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + var $255=$3; //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + var $256=(($254+$255)|0); //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + var $257=$256; //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + $r=$257; //@line 4245 "/root/emscripten/system/lib/dlmalloc.c" + var $258=$v; //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $259=$258; //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $260=$r; //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $261=$260; //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $262=(($259)>>>0) < (($261)>>>0); //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $263=(($262)&1); //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $264=(($263)==(1)); //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + var $265=(($264)|0)!=0; //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + if ($265) { __label__ = 41; break; } else { __label__ = 125; break; } //@line 4247 "/root/emscripten/system/lib/dlmalloc.c" + case 41: + var $267=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $268=(($267+24)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $269=HEAP32[(($268)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $XP=$269; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $270=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $271=(($270+12)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $272=HEAP32[(($271)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $273=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $274=(($272)|0)!=(($273)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($274) { __label__ = 42; break; } else { __label__ = 46; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + var $276=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $277=(($276+8)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $278=HEAP32[(($277)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $F=$278; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $279=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $280=(($279+12)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $281=HEAP32[(($280)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $R=$281; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $282=$F; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $283=$282; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $284=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $285=(($284+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $286=HEAP32[(($285)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $287=(($283)>>>0) >= (($286)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $288=(($287)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $289=(($288)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $290=(($289)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($290) { __label__ = 43; break; } else { __label__ = 44; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + var $292=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $293=$F; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $294=(($293+12)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($294)>>2)]=$292; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $295=$F; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $296=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $297=(($296+8)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($297)>>2)]=$295; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 45; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + __label__ = 58; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $301=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $302=(($301+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $303=(($302+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$303; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $304=HEAP32[(($303)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $R=$304; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $305=(($304)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($305) { __label__ = 48; break; } else { __label__ = 47; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + var $307=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $308=(($307+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $309=(($308)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$309; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $310=HEAP32[(($309)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $R=$310; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $311=(($310)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($311) { __label__ = 48; break; } else { __label__ = 57; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + __label__ = 49; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $314=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $315=(($314+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $316=(($315+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$316; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $317=HEAP32[(($316)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $318=(($317)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($318) { var $326 = 1;__label__ = 51; break; } else { __label__ = 50; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + var $320=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $321=(($320+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $322=(($321)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$322; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $323=HEAP32[(($322)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $324=(($323)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $326 = $324;__label__ = 51; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + var $326; + if ($326) { __label__ = 52; break; } else { __label__ = 53; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + var $328=$CP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$328; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $329=HEAP32[(($328)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $R=$329; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 49; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 53: + var $331=$RP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $332=$331; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $333=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $334=(($333+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $335=HEAP32[(($334)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $336=(($332)>>>0) >= (($335)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $337=(($336)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $338=(($337)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $339=(($338)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($339) { __label__ = 54; break; } else { __label__ = 55; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + var $341=$RP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($341)>>2)]=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 56; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 55: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + __label__ = 57; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + __label__ = 58; break; + case 58: + var $346=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $347=(($346)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($347) { __label__ = 59; break; } else { __label__ = 86; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 59: + var $349=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $350=(($349+28)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $351=HEAP32[(($350)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $352=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $353=(($352+304)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $354=(($353+($351<<2))|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $H=$354; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $355=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $356=$H; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $357=HEAP32[(($356)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $358=(($355)|0)==(($357)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($358) { __label__ = 60; break; } else { __label__ = 63; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + var $360=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $361=$H; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($361)>>2)]=$360; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $362=(($360)|0)==0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($362) { __label__ = 61; break; } else { __label__ = 62; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + var $364=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $365=(($364+28)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $366=HEAP32[(($365)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $367=1 << $366; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$367 ^ -1; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $369=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $370=(($369+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $371=HEAP32[(($370)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $372=$371 & $368; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($370)>>2)]=$372; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 62; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + __label__ = 70; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 63: + var $375=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $376=$375; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $377=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $378=(($377+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $379=HEAP32[(($378)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $380=(($376)>>>0) >= (($379)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $381=(($380)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $382=(($381)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $383=(($382)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($383) { __label__ = 64; break; } else { __label__ = 68; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 64: + var $385=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $386=(($385+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $387=(($386)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $388=HEAP32[(($387)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $389=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $390=(($388)|0)==(($389)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($390) { __label__ = 65; break; } else { __label__ = 66; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 65: + var $392=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $393=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $394=(($393+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $395=(($394)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($395)>>2)]=$392; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 67; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 66: + var $397=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $398=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $399=(($398+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $400=(($399+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($400)>>2)]=$397; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 67; break; + case 67: + __label__ = 69; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 68: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + __label__ = 70; break; + case 70: + var $405=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $406=(($405)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($406) { __label__ = 71; break; } else { __label__ = 85; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 71: + var $408=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $409=$408; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $410=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $411=(($410+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $412=HEAP32[(($411)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $413=(($409)>>>0) >= (($412)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $414=(($413)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $415=(($414)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $416=(($415)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($416) { __label__ = 72; break; } else { __label__ = 83; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 72: + var $418=$XP; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $419=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $420=(($419+24)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($420)>>2)]=$418; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $421=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $422=(($421+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $423=(($422)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $424=HEAP32[(($423)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $C0=$424; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $425=(($424)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($425) { __label__ = 73; break; } else { __label__ = 77; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 73: + var $427=$C0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $428=$427; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $429=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $430=(($429+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $431=HEAP32[(($430)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $432=(($428)>>>0) >= (($431)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $433=(($432)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $434=(($433)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $435=(($434)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($435) { __label__ = 74; break; } else { __label__ = 75; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 74: + var $437=$C0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $438=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $439=(($438+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $440=(($439)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($440)>>2)]=$437; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $441=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $442=$C0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $443=(($442+24)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($443)>>2)]=$441; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 76; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 75: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 76: + __label__ = 77; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 77: + var $447=$v; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $448=(($447+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $449=(($448+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $450=HEAP32[(($449)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + $C1=$450; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $451=(($450)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($451) { __label__ = 78; break; } else { __label__ = 82; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 78: + var $453=$C1; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $454=$453; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $455=$2; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $456=(($455+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $457=HEAP32[(($456)>>2)]; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $458=(($454)>>>0) >= (($457)>>>0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $459=(($458)&1); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $460=(($459)==(1)); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $461=(($460)|0)!=0; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + if ($461) { __label__ = 79; break; } else { __label__ = 80; break; } //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 79: + var $463=$C1; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $464=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $465=(($464+16)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $466=(($465+4)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($466)>>2)]=$463; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $467=$R; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $468=$C1; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + var $469=(($468+24)|0); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($469)>>2)]=$467; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 81; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 80: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 81: + __label__ = 82; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 82: + __label__ = 84; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 83: + _abort(); //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 84: + __label__ = 85; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 85: + __label__ = 86; break; //@line 4248 "/root/emscripten/system/lib/dlmalloc.c" + case 86: + var $477=$rsize; //@line 4249 "/root/emscripten/system/lib/dlmalloc.c" + var $478=(($477)>>>0) < 16; //@line 4249 "/root/emscripten/system/lib/dlmalloc.c" + if ($478) { __label__ = 87; break; } else { __label__ = 88; break; } //@line 4249 "/root/emscripten/system/lib/dlmalloc.c" + case 87: + var $480=$rsize; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $481=$3; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $482=((($480)+($481))|0); //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $483=$482 | 1; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $484=$483 | 2; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $485=$v; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $486=(($485+4)|0); //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($486)>>2)]=$484; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $487=$v; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $488=$487; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $489=$rsize; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $490=$3; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $491=((($489)+($490))|0); //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $492=(($488+$491)|0); //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $493=$492; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $494=(($493+4)|0); //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $495=HEAP32[(($494)>>2)]; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + var $496=$495 | 1; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($494)>>2)]=$496; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 124; break; //@line 4250 "/root/emscripten/system/lib/dlmalloc.c" + case 88: + var $498=$3; //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + var $499=$498 | 1; //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + var $500=$499 | 2; //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + var $501=$v; //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + var $502=(($501+4)|0); //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($502)>>2)]=$500; //@line 4252 "/root/emscripten/system/lib/dlmalloc.c" + var $503=$rsize; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $504=$503 | 1; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $505=$r; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $506=(($505+4)|0); //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($506)>>2)]=$504; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $507=$rsize; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $508=$r; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $509=$508; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $510=$rsize; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $511=(($509+$510)|0); //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $512=$511; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $513=(($512)|0); //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($513)>>2)]=$507; //@line 4253 "/root/emscripten/system/lib/dlmalloc.c" + var $514=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $515=$514 >>> 3; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $516=(($515)>>>0) < 32; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($516) { __label__ = 89; break; } else { __label__ = 96; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 89: + var $518=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $519=$518 >>> 3; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $I=$519; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $520=$I; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $521=$520 << 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $522=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $523=(($522+40)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $524=(($523+($521<<2))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $525=$524; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $526=$525; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $B=$526; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $527=$B; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $F5=$527; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $528=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $529=(($528)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $530=HEAP32[(($529)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $531=$I; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $532=1 << $531; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $533=$530 & $532; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $534=(($533)|0)!=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($534) { __label__ = 91; break; } else { __label__ = 90; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 90: + var $536=$I; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $537=1 << $536; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $538=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $539=(($538)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $540=HEAP32[(($539)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $541=$540 | $537; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($539)>>2)]=$541; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 95; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 91: + var $543=$B; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $544=(($543+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $545=HEAP32[(($544)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $546=$545; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $547=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $548=(($547+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $549=HEAP32[(($548)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $550=(($546)>>>0) >= (($549)>>>0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $551=(($550)&1); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $552=(($551)==(1)); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $553=(($552)|0)!=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($553) { __label__ = 92; break; } else { __label__ = 93; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 92: + var $555=$B; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $556=(($555+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $557=HEAP32[(($556)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $F5=$557; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 94; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 93: + _abort(); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 94: + __label__ = 95; break; + case 95: + var $561=$r; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $562=$B; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $563=(($562+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($563)>>2)]=$561; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $564=$r; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $565=$F5; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $566=(($565+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($566)>>2)]=$564; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $567=$F5; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $568=$r; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $569=(($568+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($569)>>2)]=$567; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $570=$B; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $571=$r; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $572=(($571+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($572)>>2)]=$570; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 123; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 96: + var $574=$r; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $575=$574; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $TP=$575; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $576=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $577=$576 >>> 8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $X8=$577; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $578=$X8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $579=(($578)|0)==0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($579) { __label__ = 97; break; } else { __label__ = 98; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 97: + $I7=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 102; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 98: + var $582=$X8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $583=(($582)>>>0) > 65535; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($583) { __label__ = 99; break; } else { __label__ = 100; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 99: + $I7=31; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 101; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 100: + var $586=$X8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $Y9=$586; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $587=$Y9; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $588=((($587)-(256))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $589=$588 >>> 16; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $590=$589 & 8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $N10=$590; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $591=$N10; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $592=$Y9; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $593=$592 << $591; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $Y9=$593; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $594=((($593)-(4096))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $595=$594 >>> 16; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $596=$595 & 4; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $K11=$596; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $597=$K11; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $598=$N10; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $599=((($598)+($597))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $N10=$599; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $600=$K11; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $601=$Y9; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $602=$601 << $600; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $Y9=$602; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $603=((($602)-(16384))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $604=$603 >>> 16; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $605=$604 & 2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $K11=$605; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $606=$N10; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $607=((($606)+($605))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $N10=$607; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $608=$N10; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $609=(((14)-($608))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $610=$K11; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $611=$Y9; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $612=$611 << $610; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $Y9=$612; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $613=$612 >>> 15; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $614=((($609)+($613))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $K11=$614; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $615=$K11; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $616=$615 << 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $617=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $618=$K11; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $619=((($618)+(7))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $620=$617 >>> (($619)>>>0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $621=$620 & 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $622=((($616)+($621))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $I7=$622; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 101; break; + case 101: + __label__ = 102; break; + case 102: + var $625=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $626=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $627=(($626+304)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $628=(($627+($625<<2))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $H6=$628; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $629=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $630=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $631=(($630+28)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($631)>>2)]=$629; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $632=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $633=(($632+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $634=(($633+4)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($634)>>2)]=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $635=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $636=(($635+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $637=(($636)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($637)>>2)]=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $638=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $639=(($638+4)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $640=HEAP32[(($639)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $641=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $642=1 << $641; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $643=$640 & $642; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $644=(($643)|0)!=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($644) { __label__ = 104; break; } else { __label__ = 103; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 103: + var $646=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $647=1 << $646; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $648=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $649=(($648+4)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $650=HEAP32[(($649)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $651=$650 | $647; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($649)>>2)]=$651; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $652=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $653=$H6; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($653)>>2)]=$652; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $654=$H6; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $655=$654; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $656=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $657=(($656+24)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($657)>>2)]=$655; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $658=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $659=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $660=(($659+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($660)>>2)]=$658; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $661=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $662=(($661+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($662)>>2)]=$658; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 122; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 104: + var $664=$H6; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $665=HEAP32[(($664)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $T=$665; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $666=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $667=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $668=(($667)|0)==31; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($668) { __label__ = 105; break; } else { __label__ = 106; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 105: + var $677 = 0;__label__ = 107; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 106: + var $671=$I7; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $672=$671 >>> 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $673=((($672)+(8))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $674=((($673)-(2))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $675=(((31)-($674))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $677 = $675;__label__ = 107; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 107: + var $677; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $678=$666 << $677; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $K12=$678; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 108; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 108: + var $680=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $681=(($680+4)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $682=HEAP32[(($681)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $683=$682 & -8; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $684=$rsize; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $685=(($683)|0)!=(($684)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($685) { __label__ = 109; break; } else { __label__ = 115; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 109: + var $687=$K12; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $688=$687 >>> 31; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $689=$688 & 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $690=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $691=(($690+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $692=(($691+($689<<2))|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $C=$692; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $693=$K12; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $694=$693 << 1; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $K12=$694; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $695=$C; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $696=HEAP32[(($695)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $697=(($696)|0)!=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($697) { __label__ = 110; break; } else { __label__ = 111; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 110: + var $699=$C; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $700=HEAP32[(($699)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $T=$700; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 114; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 111: + var $702=$C; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $703=$702; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $704=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $705=(($704+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $706=HEAP32[(($705)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $707=(($703)>>>0) >= (($706)>>>0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $708=(($707)&1); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $709=(($708)==(1)); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $710=(($709)|0)!=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($710) { __label__ = 112; break; } else { __label__ = 113; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 112: + var $712=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $713=$C; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($713)>>2)]=$712; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $714=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $715=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $716=(($715+24)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($716)>>2)]=$714; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $717=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $718=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $719=(($718+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($719)>>2)]=$717; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $720=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $721=(($720+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($721)>>2)]=$717; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 121; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 113: + _abort(); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 114: + __label__ = 120; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 115: + var $725=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $726=(($725+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $727=HEAP32[(($726)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + $F13=$727; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $728=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $729=$728; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $730=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $731=(($730+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $732=HEAP32[(($731)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $733=(($729)>>>0) >= (($732)>>>0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + if ($733) { __label__ = 116; break; } else { var $742 = 0;__label__ = 117; break; } //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 116: + var $735=$F13; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $736=$735; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $737=$2; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $738=(($737+16)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $739=HEAP32[(($738)>>2)]; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $740=(($736)>>>0) >= (($739)>>>0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $742 = $740;__label__ = 117; break; + case 117: + var $742; + var $743=(($742)&1); + var $744=(($743)==(1)); + var $745=(($744)|0)!=0; + if ($745) { __label__ = 118; break; } else { __label__ = 119; break; } + case 118: + var $747=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $748=$F13; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $749=(($748+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($749)>>2)]=$747; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $750=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $751=(($750+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($751)>>2)]=$747; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $752=$F13; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $753=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $754=(($753+8)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($754)>>2)]=$752; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $755=$T; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $756=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $757=(($756+12)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($757)>>2)]=$755; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $758=$TP; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + var $759=(($758+24)|0); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($759)>>2)]=0; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 121; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 119: + _abort(); //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 120: + __label__ = 108; break; //@line 4254 "/root/emscripten/system/lib/dlmalloc.c" + case 121: + __label__ = 122; break; + case 122: + __label__ = 123; break; + case 123: + __label__ = 124; break; + case 124: + var $766=$v; //@line 4256 "/root/emscripten/system/lib/dlmalloc.c" + var $767=$766; //@line 4256 "/root/emscripten/system/lib/dlmalloc.c" + var $768=(($767+8)|0); //@line 4256 "/root/emscripten/system/lib/dlmalloc.c" + $1=$768; //@line 4256 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 128; break; //@line 4256 "/root/emscripten/system/lib/dlmalloc.c" + case 125: + __label__ = 126; break; //@line 4258 "/root/emscripten/system/lib/dlmalloc.c" + case 126: + _abort(); //@line 4259 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4259 "/root/emscripten/system/lib/dlmalloc.c" + case 127: + $1=0; //@line 4261 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 128; break; //@line 4261 "/root/emscripten/system/lib/dlmalloc.c" + case 128: + var $773=$1; //@line 4262 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $773; //@line 4262 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_tmalloc_large["X"]=1; + +function _sys_alloc($m, $nb) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $tbase; + var $tsize; + var $mmap_flag; + var $mem; + var $br; + var $ss; + var $asize; + var $base; + var $esize; + var $end; + var $asize1; + var $br2; + var $end3; + var $ssize; + var $mn; + var $sp; + var $oldbase; + var $rsize; + var $p; + var $r; + $2=$m; + $3=$nb; + $tbase=-1; //@line 3876 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=0; //@line 3877 "/root/emscripten/system/lib/dlmalloc.c" + $mmap_flag=0; //@line 3878 "/root/emscripten/system/lib/dlmalloc.c" + var $4=HEAP32[((((_mparams)|0))>>2)]; //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + var $5=(($4)|0)!=0; //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + if ($5) { var $10 = 1;__label__ = 4; break; } else { __label__ = 3; break; } //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $7=_init_mparams(); //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + var $8=(($7)|0)!=0; //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + var $10 = $8;__label__ = 4; break; //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $10; + var $11=(($10)&1); //@line 3880 "/root/emscripten/system/lib/dlmalloc.c" + var $12=$2; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $13=(($12+440)|0); //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $14=HEAP32[(($13)>>2)]; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$14 & 0; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $16=(($15)|0)!=0; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + if ($16) { __label__ = 5; break; } else { __label__ = 10; break; } //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $18=$3; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $19=HEAP32[((((_mparams+12)|0))>>2)]; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $20=(($18)>>>0) >= (($19)>>>0); //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + if ($20) { __label__ = 6; break; } else { __label__ = 10; break; } //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $22=$2; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $23=(($22+12)|0); //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $24=HEAP32[(($23)>>2)]; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + var $25=(($24)|0)!=0; //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + if ($25) { __label__ = 7; break; } else { __label__ = 10; break; } //@line 3883 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $27=$2; //@line 3884 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$3; //@line 3884 "/root/emscripten/system/lib/dlmalloc.c" + var $29=_mmap_alloc($27, $28); //@line 3884 "/root/emscripten/system/lib/dlmalloc.c" + $mem=$29; //@line 3884 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$mem; //@line 3885 "/root/emscripten/system/lib/dlmalloc.c" + var $31=(($30)|0)!=0; //@line 3885 "/root/emscripten/system/lib/dlmalloc.c" + if ($31) { __label__ = 8; break; } else { __label__ = 9; break; } //@line 3885 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $33=$mem; //@line 3886 "/root/emscripten/system/lib/dlmalloc.c" + $1=$33; //@line 3886 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 93; break; //@line 3886 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + __label__ = 10; break; //@line 3887 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $36=$2; //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + var $37=(($36+440)|0); //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + var $38=HEAP32[(($37)>>2)]; //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + var $39=$38 & 4; //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + var $40=(($39)|0)!=0; //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + if ($40) { __label__ = 43; break; } else { __label__ = 11; break; } //@line 3911 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + $br=-1; //@line 3912 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$2; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $43=(($42+24)|0); //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $44=HEAP32[(($43)>>2)]; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $45=(($44)|0)==0; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + if ($45) { __label__ = 12; break; } else { __label__ = 13; break; } //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $55 = 0;__label__ = 14; break; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $48=$2; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $49=$2; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $50=(($49+24)|0); //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $51=HEAP32[(($50)>>2)]; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $52=$51; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $53=_segment_holding($48, $52); //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + var $55 = $53;__label__ = 14; break; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $55; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + $ss=$55; //@line 3913 "/root/emscripten/system/lib/dlmalloc.c" + $asize=0; //@line 3914 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$ss; //@line 3917 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56)|0)==0; //@line 3917 "/root/emscripten/system/lib/dlmalloc.c" + if ($57) { __label__ = 15; break; } else { __label__ = 23; break; } //@line 3917 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $59=_sbrk(0); //@line 3918 "/root/emscripten/system/lib/dlmalloc.c" + $base=$59; //@line 3918 "/root/emscripten/system/lib/dlmalloc.c" + var $60=$base; //@line 3919 "/root/emscripten/system/lib/dlmalloc.c" + var $61=(($60)|0)!=-1; //@line 3919 "/root/emscripten/system/lib/dlmalloc.c" + if ($61) { __label__ = 16; break; } else { __label__ = 22; break; } //@line 3919 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + var $63=$3; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $64=((($63)+(48))|0); //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $65=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $66=((($65)-(1))|0); //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $67=((($64)+($66))|0); //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $68=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $69=((($68)-(1))|0); //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $70=$69 ^ -1; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $71=$67 & $70; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + $asize=$71; //@line 3920 "/root/emscripten/system/lib/dlmalloc.c" + var $72=$base; //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + var $73=$72; //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + var $74=HEAP32[((((_mparams+4)|0))>>2)]; //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + var $75=((($74)-(1))|0); //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + var $76=$73 & $75; //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + var $77=(($76)|0)==0; //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + if ($77) { __label__ = 18; break; } else { __label__ = 17; break; } //@line 3922 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $79=$base; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $80=$79; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $81=HEAP32[((((_mparams+4)|0))>>2)]; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $82=((($81)-(1))|0); //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $83=((($80)+($82))|0); //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $84=HEAP32[((((_mparams+4)|0))>>2)]; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $85=((($84)-(1))|0); //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $86=$85 ^ -1; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $87=$83 & $86; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $88=$base; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $89=$88; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $90=((($87)-($89))|0); //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $91=$asize; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + var $92=((($91)+($90))|0); //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + $asize=$92; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 18; break; //@line 3923 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $94=$asize; //@line 3925 "/root/emscripten/system/lib/dlmalloc.c" + var $95=(($94)>>>0) < 2147483647; //@line 3925 "/root/emscripten/system/lib/dlmalloc.c" + if ($95) { __label__ = 19; break; } else { __label__ = 21; break; } //@line 3925 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $97=$asize; //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + var $98=_sbrk($97); //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + $br=$98; //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + var $99=$base; //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + var $100=(($98)|0)==(($99)|0); //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + if ($100) { __label__ = 20; break; } else { __label__ = 21; break; } //@line 3926 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + var $102=$base; //@line 3927 "/root/emscripten/system/lib/dlmalloc.c" + $tbase=$102; //@line 3927 "/root/emscripten/system/lib/dlmalloc.c" + var $103=$asize; //@line 3928 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$103; //@line 3928 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 21; break; //@line 3929 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + __label__ = 22; break; //@line 3930 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + __label__ = 27; break; //@line 3931 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + var $107=$3; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $108=$2; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $109=(($108+12)|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $110=HEAP32[(($109)>>2)]; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $111=((($107)-($110))|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $112=((($111)+(48))|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $113=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $114=((($113)-(1))|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $115=((($112)+($114))|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $116=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $117=((($116)-(1))|0); //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $118=$117 ^ -1; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $119=$115 & $118; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + $asize=$119; //@line 3934 "/root/emscripten/system/lib/dlmalloc.c" + var $120=$asize; //@line 3936 "/root/emscripten/system/lib/dlmalloc.c" + var $121=(($120)>>>0) < 2147483647; //@line 3936 "/root/emscripten/system/lib/dlmalloc.c" + if ($121) { __label__ = 24; break; } else { __label__ = 26; break; } //@line 3936 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $123=$asize; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $124=_sbrk($123); //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + $br=$124; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $125=$ss; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $126=(($125)|0); //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $127=HEAP32[(($126)>>2)]; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $128=$ss; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $129=(($128+4)|0); //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $130=HEAP32[(($129)>>2)]; //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $131=(($127+$130)|0); //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + var $132=(($124)|0)==(($131)|0); //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + if ($132) { __label__ = 25; break; } else { __label__ = 26; break; } //@line 3937 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $134=$br; //@line 3938 "/root/emscripten/system/lib/dlmalloc.c" + $tbase=$134; //@line 3938 "/root/emscripten/system/lib/dlmalloc.c" + var $135=$asize; //@line 3939 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$135; //@line 3939 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 26; break; //@line 3940 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + __label__ = 27; break; + case 27: + var $138=$tbase; //@line 3943 "/root/emscripten/system/lib/dlmalloc.c" + var $139=(($138)|0)==-1; //@line 3943 "/root/emscripten/system/lib/dlmalloc.c" + if ($139) { __label__ = 28; break; } else { __label__ = 42; break; } //@line 3943 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + var $141=$br; //@line 3944 "/root/emscripten/system/lib/dlmalloc.c" + var $142=(($141)|0)!=-1; //@line 3944 "/root/emscripten/system/lib/dlmalloc.c" + if ($142) { __label__ = 29; break; } else { __label__ = 38; break; } //@line 3944 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + var $144=$asize; //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + var $145=(($144)>>>0) < 2147483647; //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + if ($145) { __label__ = 30; break; } else { __label__ = 37; break; } //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $147=$asize; //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + var $148=$3; //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + var $149=((($148)+(48))|0); //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + var $150=(($147)>>>0) < (($149)>>>0); //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + if ($150) { __label__ = 31; break; } else { __label__ = 37; break; } //@line 3945 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $152=$3; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $153=((($152)+(48))|0); //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $154=$asize; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $155=((($153)-($154))|0); //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $156=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $157=((($156)-(1))|0); //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $158=((($155)+($157))|0); //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $159=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $160=((($159)-(1))|0); //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $161=$160 ^ -1; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $162=$158 & $161; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + $esize=$162; //@line 3947 "/root/emscripten/system/lib/dlmalloc.c" + var $163=$esize; //@line 3948 "/root/emscripten/system/lib/dlmalloc.c" + var $164=(($163)>>>0) < 2147483647; //@line 3948 "/root/emscripten/system/lib/dlmalloc.c" + if ($164) { __label__ = 32; break; } else { __label__ = 36; break; } //@line 3948 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $166=$esize; //@line 3949 "/root/emscripten/system/lib/dlmalloc.c" + var $167=_sbrk($166); //@line 3949 "/root/emscripten/system/lib/dlmalloc.c" + $end=$167; //@line 3949 "/root/emscripten/system/lib/dlmalloc.c" + var $168=$end; //@line 3950 "/root/emscripten/system/lib/dlmalloc.c" + var $169=(($168)|0)!=-1; //@line 3950 "/root/emscripten/system/lib/dlmalloc.c" + if ($169) { __label__ = 33; break; } else { __label__ = 34; break; } //@line 3950 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + var $171=$esize; //@line 3951 "/root/emscripten/system/lib/dlmalloc.c" + var $172=$asize; //@line 3951 "/root/emscripten/system/lib/dlmalloc.c" + var $173=((($172)+($171))|0); //@line 3951 "/root/emscripten/system/lib/dlmalloc.c" + $asize=$173; //@line 3951 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 35; break; //@line 3951 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $175=$asize; //@line 3953 "/root/emscripten/system/lib/dlmalloc.c" + var $176=(((-$175))|0); //@line 3953 "/root/emscripten/system/lib/dlmalloc.c" + var $177=_sbrk($176); //@line 3953 "/root/emscripten/system/lib/dlmalloc.c" + $br=-1; //@line 3954 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 35; break; + case 35: + __label__ = 36; break; //@line 3956 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + __label__ = 37; break; //@line 3957 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + __label__ = 38; break; //@line 3958 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $182=$br; //@line 3959 "/root/emscripten/system/lib/dlmalloc.c" + var $183=(($182)|0)!=-1; //@line 3959 "/root/emscripten/system/lib/dlmalloc.c" + if ($183) { __label__ = 39; break; } else { __label__ = 40; break; } //@line 3959 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + var $185=$br; //@line 3960 "/root/emscripten/system/lib/dlmalloc.c" + $tbase=$185; //@line 3960 "/root/emscripten/system/lib/dlmalloc.c" + var $186=$asize; //@line 3961 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$186; //@line 3961 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 41; break; //@line 3962 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + var $188=$2; //@line 3964 "/root/emscripten/system/lib/dlmalloc.c" + var $189=(($188+440)|0); //@line 3964 "/root/emscripten/system/lib/dlmalloc.c" + var $190=HEAP32[(($189)>>2)]; //@line 3964 "/root/emscripten/system/lib/dlmalloc.c" + var $191=$190 | 4; //@line 3964 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($189)>>2)]=$191; //@line 3964 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 41; break; + case 41: + __label__ = 42; break; //@line 3965 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + __label__ = 43; break; //@line 3968 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + var $195=$tbase; //@line 3982 "/root/emscripten/system/lib/dlmalloc.c" + var $196=(($195)|0)==-1; //@line 3982 "/root/emscripten/system/lib/dlmalloc.c" + if ($196) { __label__ = 44; break; } else { __label__ = 53; break; } //@line 3982 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + var $198=$3; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $199=((($198)+(48))|0); //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $200=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $201=((($200)-(1))|0); //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $202=((($199)+($201))|0); //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $203=HEAP32[((((_mparams+8)|0))>>2)]; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $204=((($203)-(1))|0); //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $205=$204 ^ -1; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $206=$202 & $205; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + $asize1=$206; //@line 3983 "/root/emscripten/system/lib/dlmalloc.c" + var $207=$asize1; //@line 3984 "/root/emscripten/system/lib/dlmalloc.c" + var $208=(($207)>>>0) < 2147483647; //@line 3984 "/root/emscripten/system/lib/dlmalloc.c" + if ($208) { __label__ = 45; break; } else { __label__ = 52; break; } //@line 3984 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + $br2=-1; //@line 3985 "/root/emscripten/system/lib/dlmalloc.c" + $end3=-1; //@line 3986 "/root/emscripten/system/lib/dlmalloc.c" + var $210=$asize1; //@line 3988 "/root/emscripten/system/lib/dlmalloc.c" + var $211=_sbrk($210); //@line 3988 "/root/emscripten/system/lib/dlmalloc.c" + $br2=$211; //@line 3988 "/root/emscripten/system/lib/dlmalloc.c" + var $212=_sbrk(0); //@line 3989 "/root/emscripten/system/lib/dlmalloc.c" + $end3=$212; //@line 3989 "/root/emscripten/system/lib/dlmalloc.c" + var $213=$br2; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + var $214=(($213)|0)!=-1; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + if ($214) { __label__ = 46; break; } else { __label__ = 51; break; } //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $216=$end3; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + var $217=(($216)|0)!=-1; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + if ($217) { __label__ = 47; break; } else { __label__ = 51; break; } //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + var $219=$br2; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + var $220=$end3; //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + var $221=(($219)>>>0) < (($220)>>>0); //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + if ($221) { __label__ = 48; break; } else { __label__ = 51; break; } //@line 3991 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + var $223=$end3; //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + var $224=$br2; //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + var $225=$223; //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + var $226=$224; //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + var $227=((($225)-($226))|0); //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + $ssize=$227; //@line 3992 "/root/emscripten/system/lib/dlmalloc.c" + var $228=$ssize; //@line 3993 "/root/emscripten/system/lib/dlmalloc.c" + var $229=$3; //@line 3993 "/root/emscripten/system/lib/dlmalloc.c" + var $230=((($229)+(40))|0); //@line 3993 "/root/emscripten/system/lib/dlmalloc.c" + var $231=(($228)>>>0) > (($230)>>>0); //@line 3993 "/root/emscripten/system/lib/dlmalloc.c" + if ($231) { __label__ = 49; break; } else { __label__ = 50; break; } //@line 3993 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $233=$br2; //@line 3994 "/root/emscripten/system/lib/dlmalloc.c" + $tbase=$233; //@line 3994 "/root/emscripten/system/lib/dlmalloc.c" + var $234=$ssize; //@line 3995 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$234; //@line 3995 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 50; break; //@line 3996 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + __label__ = 51; break; //@line 3997 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + __label__ = 52; break; //@line 3998 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + __label__ = 53; break; //@line 3999 "/root/emscripten/system/lib/dlmalloc.c" + case 53: + var $239=$tbase; //@line 4001 "/root/emscripten/system/lib/dlmalloc.c" + var $240=(($239)|0)!=-1; //@line 4001 "/root/emscripten/system/lib/dlmalloc.c" + if ($240) { __label__ = 54; break; } else { __label__ = 92; break; } //@line 4001 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + var $242=$tsize; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $243=$2; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $244=(($243+432)|0); //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $245=HEAP32[(($244)>>2)]; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $246=((($245)+($242))|0); //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($244)>>2)]=$246; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $247=$2; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($247+436)|0); //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $249=HEAP32[(($248)>>2)]; //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + var $250=(($246)>>>0) > (($249)>>>0); //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + if ($250) { __label__ = 55; break; } else { __label__ = 56; break; } //@line 4003 "/root/emscripten/system/lib/dlmalloc.c" + case 55: + var $252=$2; //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + var $253=(($252+432)|0); //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + var $254=HEAP32[(($253)>>2)]; //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + var $255=$2; //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + var $256=(($255+436)|0); //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($256)>>2)]=$254; //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 56; break; //@line 4004 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + var $258=$2; //@line 4006 "/root/emscripten/system/lib/dlmalloc.c" + var $259=(($258+24)|0); //@line 4006 "/root/emscripten/system/lib/dlmalloc.c" + var $260=HEAP32[(($259)>>2)]; //@line 4006 "/root/emscripten/system/lib/dlmalloc.c" + var $261=(($260)|0)!=0; //@line 4006 "/root/emscripten/system/lib/dlmalloc.c" + if ($261) { __label__ = 64; break; } else { __label__ = 57; break; } //@line 4006 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + var $263=$2; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $264=(($263+16)|0); //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $265=HEAP32[(($264)>>2)]; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $266=(($265)|0)==0; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + if ($266) { __label__ = 59; break; } else { __label__ = 58; break; } //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + case 58: + var $268=$tbase; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $269=$2; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $270=(($269+16)|0); //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $271=HEAP32[(($270)>>2)]; //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + var $272=(($268)>>>0) < (($271)>>>0); //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + if ($272) { __label__ = 59; break; } else { __label__ = 60; break; } //@line 4007 "/root/emscripten/system/lib/dlmalloc.c" + case 59: + var $274=$tbase; //@line 4008 "/root/emscripten/system/lib/dlmalloc.c" + var $275=$2; //@line 4008 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($275+16)|0); //@line 4008 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($276)>>2)]=$274; //@line 4008 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 60; break; //@line 4008 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + var $278=$tbase; //@line 4009 "/root/emscripten/system/lib/dlmalloc.c" + var $279=$2; //@line 4009 "/root/emscripten/system/lib/dlmalloc.c" + var $280=(($279+444)|0); //@line 4009 "/root/emscripten/system/lib/dlmalloc.c" + var $281=(($280)|0); //@line 4009 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($281)>>2)]=$278; //@line 4009 "/root/emscripten/system/lib/dlmalloc.c" + var $282=$tsize; //@line 4010 "/root/emscripten/system/lib/dlmalloc.c" + var $283=$2; //@line 4010 "/root/emscripten/system/lib/dlmalloc.c" + var $284=(($283+444)|0); //@line 4010 "/root/emscripten/system/lib/dlmalloc.c" + var $285=(($284+4)|0); //@line 4010 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($285)>>2)]=$282; //@line 4010 "/root/emscripten/system/lib/dlmalloc.c" + var $286=$mmap_flag; //@line 4011 "/root/emscripten/system/lib/dlmalloc.c" + var $287=$2; //@line 4011 "/root/emscripten/system/lib/dlmalloc.c" + var $288=(($287+444)|0); //@line 4011 "/root/emscripten/system/lib/dlmalloc.c" + var $289=(($288+12)|0); //@line 4011 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($289)>>2)]=$286; //@line 4011 "/root/emscripten/system/lib/dlmalloc.c" + var $290=HEAP32[((((_mparams)|0))>>2)]; //@line 4012 "/root/emscripten/system/lib/dlmalloc.c" + var $291=$2; //@line 4012 "/root/emscripten/system/lib/dlmalloc.c" + var $292=(($291+36)|0); //@line 4012 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($292)>>2)]=$290; //@line 4012 "/root/emscripten/system/lib/dlmalloc.c" + var $293=$2; //@line 4013 "/root/emscripten/system/lib/dlmalloc.c" + var $294=(($293+32)|0); //@line 4013 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($294)>>2)]=-1; //@line 4013 "/root/emscripten/system/lib/dlmalloc.c" + var $295=$2; //@line 4014 "/root/emscripten/system/lib/dlmalloc.c" + _init_bins($295); //@line 4014 "/root/emscripten/system/lib/dlmalloc.c" + var $296=$2; //@line 4016 "/root/emscripten/system/lib/dlmalloc.c" + var $297=(($296)|0)==((__gm_)|0); //@line 4016 "/root/emscripten/system/lib/dlmalloc.c" + if ($297) { __label__ = 61; break; } else { __label__ = 62; break; } //@line 4016 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + var $299=$2; //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + var $300=$tbase; //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + var $301=$300; //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + var $302=$tsize; //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + var $303=((($302)-(40))|0); //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + _init_top($299, $301, $303); //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 63; break; //@line 4017 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + var $305=$2; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $306=$305; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $307=((($306)-(8))|0); //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $308=$307; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $309=$308; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $310=$2; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $311=$310; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $312=((($311)-(8))|0); //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $313=$312; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $314=(($313+4)|0); //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $315=HEAP32[(($314)>>2)]; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $316=$315 & -8; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $317=(($309+$316)|0); //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $318=$317; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + $mn=$318; //@line 4022 "/root/emscripten/system/lib/dlmalloc.c" + var $319=$2; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $320=$mn; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $321=$tbase; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $322=$tsize; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $323=(($321+$322)|0); //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $324=$mn; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $325=$324; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $326=$323; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $327=$325; //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $328=((($326)-($327))|0); //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + var $329=((($328)-(40))|0); //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + _init_top($319, $320, $329); //@line 4023 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 63; break; + case 63: + __label__ = 89; break; //@line 4025 "/root/emscripten/system/lib/dlmalloc.c" + case 64: + var $332=$2; //@line 4029 "/root/emscripten/system/lib/dlmalloc.c" + var $333=(($332+444)|0); //@line 4029 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$333; //@line 4029 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 65; break; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + case 65: + var $335=$sp; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $336=(($335)|0)!=0; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + if ($336) { __label__ = 66; break; } else { var $348 = 0;__label__ = 67; break; } //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + case 66: + var $338=$tbase; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $339=$sp; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $340=(($339)|0); //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $341=HEAP32[(($340)>>2)]; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $342=$sp; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $343=(($342+4)|0); //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $344=HEAP32[(($343)>>2)]; //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $345=(($341+$344)|0); //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $346=(($338)|0)!=(($345)|0); //@line 4031 "/root/emscripten/system/lib/dlmalloc.c" + var $348 = $346;__label__ = 67; break; + case 67: + var $348; + if ($348) { __label__ = 68; break; } else { __label__ = 69; break; } + case 68: + var $350=$sp; //@line 4032 "/root/emscripten/system/lib/dlmalloc.c" + var $351=(($350+8)|0); //@line 4032 "/root/emscripten/system/lib/dlmalloc.c" + var $352=HEAP32[(($351)>>2)]; //@line 4032 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$352; //@line 4032 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 65; break; //@line 4032 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + var $354=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $355=(($354)|0)!=0; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + if ($355) { __label__ = 70; break; } else { __label__ = 75; break; } //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + case 70: + var $357=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $358=(($357+12)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $359=HEAP32[(($358)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $360=$359 & 8; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $361=(($360)|0)!=0; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + if ($361) { __label__ = 75; break; } else { __label__ = 71; break; } //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + case 71: + var $363=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $364=(($363+12)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $365=HEAP32[(($364)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $366=$365 & 0; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $367=$mmap_flag; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $368=(($366)|0)==(($367)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + if ($368) { __label__ = 72; break; } else { __label__ = 75; break; } //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + case 72: + var $370=$2; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $371=(($370+24)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $372=HEAP32[(($371)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $373=$372; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $374=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $375=(($374)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $376=HEAP32[(($375)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $377=(($373)>>>0) >= (($376)>>>0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + if ($377) { __label__ = 73; break; } else { __label__ = 75; break; } //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + case 73: + var $379=$2; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $380=(($379+24)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $381=HEAP32[(($380)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $382=$381; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $383=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $384=(($383)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $385=HEAP32[(($384)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $386=$sp; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $387=(($386+4)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $388=HEAP32[(($387)>>2)]; //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $389=(($385+$388)|0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + var $390=(($382)>>>0) < (($389)>>>0); //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + if ($390) { __label__ = 74; break; } else { __label__ = 75; break; } //@line 4033 "/root/emscripten/system/lib/dlmalloc.c" + case 74: + var $392=$tsize; //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + var $393=$sp; //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + var $394=(($393+4)|0); //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + var $395=HEAP32[(($394)>>2)]; //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + var $396=((($395)+($392))|0); //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($394)>>2)]=$396; //@line 4037 "/root/emscripten/system/lib/dlmalloc.c" + var $397=$2; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $398=$2; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $399=(($398+24)|0); //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $400=HEAP32[(($399)>>2)]; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $401=$2; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $402=(($401+12)|0); //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $403=HEAP32[(($402)>>2)]; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $404=$tsize; //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + var $405=((($403)+($404))|0); //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + _init_top($397, $400, $405); //@line 4038 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 88; break; //@line 4039 "/root/emscripten/system/lib/dlmalloc.c" + case 75: + var $407=$tbase; //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + var $408=$2; //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + var $409=(($408+16)|0); //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + var $410=HEAP32[(($409)>>2)]; //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + var $411=(($407)>>>0) < (($410)>>>0); //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + if ($411) { __label__ = 76; break; } else { __label__ = 77; break; } //@line 4041 "/root/emscripten/system/lib/dlmalloc.c" + case 76: + var $413=$tbase; //@line 4042 "/root/emscripten/system/lib/dlmalloc.c" + var $414=$2; //@line 4042 "/root/emscripten/system/lib/dlmalloc.c" + var $415=(($414+16)|0); //@line 4042 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($415)>>2)]=$413; //@line 4042 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 77; break; //@line 4042 "/root/emscripten/system/lib/dlmalloc.c" + case 77: + var $417=$2; //@line 4043 "/root/emscripten/system/lib/dlmalloc.c" + var $418=(($417+444)|0); //@line 4043 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$418; //@line 4043 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 78; break; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + case 78: + var $420=$sp; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $421=(($420)|0)!=0; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + if ($421) { __label__ = 79; break; } else { var $431 = 0;__label__ = 80; break; } //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + case 79: + var $423=$sp; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $424=(($423)|0); //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $425=HEAP32[(($424)>>2)]; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $426=$tbase; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $427=$tsize; //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $428=(($426+$427)|0); //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $429=(($425)|0)!=(($428)|0); //@line 4044 "/root/emscripten/system/lib/dlmalloc.c" + var $431 = $429;__label__ = 80; break; + case 80: + var $431; + if ($431) { __label__ = 81; break; } else { __label__ = 82; break; } + case 81: + var $433=$sp; //@line 4045 "/root/emscripten/system/lib/dlmalloc.c" + var $434=(($433+8)|0); //@line 4045 "/root/emscripten/system/lib/dlmalloc.c" + var $435=HEAP32[(($434)>>2)]; //@line 4045 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$435; //@line 4045 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 78; break; //@line 4045 "/root/emscripten/system/lib/dlmalloc.c" + case 82: + var $437=$sp; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $438=(($437)|0)!=0; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + if ($438) { __label__ = 83; break; } else { __label__ = 86; break; } //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + case 83: + var $440=$sp; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $441=(($440+12)|0); //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $442=HEAP32[(($441)>>2)]; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $443=$442 & 8; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $444=(($443)|0)!=0; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + if ($444) { __label__ = 86; break; } else { __label__ = 84; break; } //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + case 84: + var $446=$sp; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $447=(($446+12)|0); //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $448=HEAP32[(($447)>>2)]; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $449=$448 & 0; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $450=$mmap_flag; //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + var $451=(($449)|0)==(($450)|0); //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + if ($451) { __label__ = 85; break; } else { __label__ = 86; break; } //@line 4046 "/root/emscripten/system/lib/dlmalloc.c" + case 85: + var $453=$sp; //@line 4049 "/root/emscripten/system/lib/dlmalloc.c" + var $454=(($453)|0); //@line 4049 "/root/emscripten/system/lib/dlmalloc.c" + var $455=HEAP32[(($454)>>2)]; //@line 4049 "/root/emscripten/system/lib/dlmalloc.c" + $oldbase=$455; //@line 4049 "/root/emscripten/system/lib/dlmalloc.c" + var $456=$tbase; //@line 4050 "/root/emscripten/system/lib/dlmalloc.c" + var $457=$sp; //@line 4050 "/root/emscripten/system/lib/dlmalloc.c" + var $458=(($457)|0); //@line 4050 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($458)>>2)]=$456; //@line 4050 "/root/emscripten/system/lib/dlmalloc.c" + var $459=$tsize; //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + var $460=$sp; //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + var $461=(($460+4)|0); //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + var $462=HEAP32[(($461)>>2)]; //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + var $463=((($462)+($459))|0); //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($461)>>2)]=$463; //@line 4051 "/root/emscripten/system/lib/dlmalloc.c" + var $464=$2; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + var $465=$tbase; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + var $466=$oldbase; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + var $467=$3; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + var $468=_prepend_alloc($464, $465, $466, $467); //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + $1=$468; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 93; break; //@line 4052 "/root/emscripten/system/lib/dlmalloc.c" + case 86: + var $470=$2; //@line 4055 "/root/emscripten/system/lib/dlmalloc.c" + var $471=$tbase; //@line 4055 "/root/emscripten/system/lib/dlmalloc.c" + var $472=$tsize; //@line 4055 "/root/emscripten/system/lib/dlmalloc.c" + var $473=$mmap_flag; //@line 4055 "/root/emscripten/system/lib/dlmalloc.c" + _add_segment($470, $471, $472, $473); //@line 4055 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 87; break; + case 87: + __label__ = 88; break; + case 88: + __label__ = 89; break; + case 89: + var $477=$3; //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + var $478=$2; //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + var $479=(($478+12)|0); //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + var $480=HEAP32[(($479)>>2)]; //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + var $481=(($477)>>>0) < (($480)>>>0); //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + if ($481) { __label__ = 90; break; } else { __label__ = 91; break; } //@line 4059 "/root/emscripten/system/lib/dlmalloc.c" + case 90: + var $483=$3; //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + var $484=$2; //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + var $485=(($484+12)|0); //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + var $486=HEAP32[(($485)>>2)]; //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + var $487=((($486)-($483))|0); //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($485)>>2)]=$487; //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + $rsize=$487; //@line 4060 "/root/emscripten/system/lib/dlmalloc.c" + var $488=$2; //@line 4061 "/root/emscripten/system/lib/dlmalloc.c" + var $489=(($488+24)|0); //@line 4061 "/root/emscripten/system/lib/dlmalloc.c" + var $490=HEAP32[(($489)>>2)]; //@line 4061 "/root/emscripten/system/lib/dlmalloc.c" + $p=$490; //@line 4061 "/root/emscripten/system/lib/dlmalloc.c" + var $491=$p; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $492=$491; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $493=$3; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $494=(($492+$493)|0); //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $495=$494; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $496=$2; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $497=(($496+24)|0); //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($497)>>2)]=$495; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + $r=$495; //@line 4062 "/root/emscripten/system/lib/dlmalloc.c" + var $498=$rsize; //@line 4063 "/root/emscripten/system/lib/dlmalloc.c" + var $499=$498 | 1; //@line 4063 "/root/emscripten/system/lib/dlmalloc.c" + var $500=$r; //@line 4063 "/root/emscripten/system/lib/dlmalloc.c" + var $501=(($500+4)|0); //@line 4063 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($501)>>2)]=$499; //@line 4063 "/root/emscripten/system/lib/dlmalloc.c" + var $502=$3; //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + var $503=$502 | 1; //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + var $504=$503 | 2; //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + var $505=$p; //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + var $506=(($505+4)|0); //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($506)>>2)]=$504; //@line 4064 "/root/emscripten/system/lib/dlmalloc.c" + var $507=$p; //@line 4067 "/root/emscripten/system/lib/dlmalloc.c" + var $508=$507; //@line 4067 "/root/emscripten/system/lib/dlmalloc.c" + var $509=(($508+8)|0); //@line 4067 "/root/emscripten/system/lib/dlmalloc.c" + $1=$509; //@line 4067 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 93; break; //@line 4067 "/root/emscripten/system/lib/dlmalloc.c" + case 91: + __label__ = 92; break; //@line 4069 "/root/emscripten/system/lib/dlmalloc.c" + case 92: + var $512=___errno(); //@line 4071 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($512)>>2)]=12; //@line 4071 "/root/emscripten/system/lib/dlmalloc.c" + $1=0; //@line 4072 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 93; break; //@line 4072 "/root/emscripten/system/lib/dlmalloc.c" + case 93: + var $514=$1; //@line 4073 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $514; //@line 4073 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_sys_alloc["X"]=1; + +function _free($mem) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $p; + var $psize; + var $next; + var $prevsize; + var $prev; + var $F; + var $B; + var $I; + var $TP; + var $XP; + var $R; + var $F1; + var $RP; + var $CP; + var $H; + var $C0; + var $C1; + var $tsize; + var $dsize; + var $nsize; + var $F2; + var $B3; + var $I4; + var $TP5; + var $XP6; + var $R7; + var $F8; + var $RP9; + var $CP10; + var $H11; + var $C012; + var $C113; + var $I14; + var $B15; + var $F16; + var $tp; + var $H17; + var $I18; + var $X; + var $Y; + var $N; + var $K; + var $T; + var $K19; + var $C; + var $F20; + $1=$mem; + var $2=$1; //@line 4741 "/root/emscripten/system/lib/dlmalloc.c" + var $3=(($2)|0)!=0; //@line 4741 "/root/emscripten/system/lib/dlmalloc.c" + if ($3) { __label__ = 3; break; } else { __label__ = 197; break; } //@line 4741 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $5=$1; //@line 4742 "/root/emscripten/system/lib/dlmalloc.c" + var $6=((($5)-(8))|0); //@line 4742 "/root/emscripten/system/lib/dlmalloc.c" + var $7=$6; //@line 4742 "/root/emscripten/system/lib/dlmalloc.c" + $p=$7; //@line 4742 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$p; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $9=$8; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $10=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $11=(($9)>>>0) >= (($10)>>>0); //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + if ($11) { __label__ = 4; break; } else { var $19 = 0;__label__ = 5; break; } //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $13=$p; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $14=(($13+4)|0); //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $15=HEAP32[(($14)>>2)]; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$15 & 3; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $17=(($16)|0)!=1; //@line 4754 "/root/emscripten/system/lib/dlmalloc.c" + var $19 = $17;__label__ = 5; break; + case 5: + var $19; + var $20=(($19)&1); + var $21=(($20)==(1)); + var $22=(($21)|0)!=0; + if ($22) { __label__ = 6; break; } else { __label__ = 194; break; } + case 6: + var $24=$p; //@line 4755 "/root/emscripten/system/lib/dlmalloc.c" + var $25=(($24+4)|0); //@line 4755 "/root/emscripten/system/lib/dlmalloc.c" + var $26=HEAP32[(($25)>>2)]; //@line 4755 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$26 & -8; //@line 4755 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$27; //@line 4755 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$p; //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + var $29=$28; //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$psize; //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + var $31=(($29+$30)|0); //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + var $32=$31; //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + $next=$32; //@line 4756 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$p; //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + var $34=(($33+4)|0); //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + var $35=HEAP32[(($34)>>2)]; //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$35 & 1; //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + var $37=(($36)|0)!=0; //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + if ($37) { __label__ = 78; break; } else { __label__ = 7; break; } //@line 4757 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $39=$p; //@line 4758 "/root/emscripten/system/lib/dlmalloc.c" + var $40=(($39)|0); //@line 4758 "/root/emscripten/system/lib/dlmalloc.c" + var $41=HEAP32[(($40)>>2)]; //@line 4758 "/root/emscripten/system/lib/dlmalloc.c" + $prevsize=$41; //@line 4758 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$p; //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + var $43=(($42+4)|0); //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + var $44=HEAP32[(($43)>>2)]; //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$44 & 3; //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + var $46=(($45)|0)==0; //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + if ($46) { __label__ = 8; break; } else { __label__ = 9; break; } //@line 4759 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $48=$prevsize; //@line 4760 "/root/emscripten/system/lib/dlmalloc.c" + var $49=((($48)+(16))|0); //@line 4760 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$psize; //@line 4760 "/root/emscripten/system/lib/dlmalloc.c" + var $51=((($50)+($49))|0); //@line 4760 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$51; //@line 4760 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 196; break; //@line 4763 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $53=$p; //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $54=$53; //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $55=$prevsize; //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $56=(((-$55))|0); //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($54+$56)|0); //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $58=$57; //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + $prev=$58; //@line 4766 "/root/emscripten/system/lib/dlmalloc.c" + var $59=$prevsize; //@line 4767 "/root/emscripten/system/lib/dlmalloc.c" + var $60=$psize; //@line 4767 "/root/emscripten/system/lib/dlmalloc.c" + var $61=((($60)+($59))|0); //@line 4767 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$61; //@line 4767 "/root/emscripten/system/lib/dlmalloc.c" + var $62=$prev; //@line 4768 "/root/emscripten/system/lib/dlmalloc.c" + $p=$62; //@line 4768 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$prev; //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $64=$63; //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $65=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $66=(($64)>>>0) >= (($65)>>>0); //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $67=(($66)&1); //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $68=(($67)==(1)); //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + var $69=(($68)|0)!=0; //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + if ($69) { __label__ = 10; break; } else { __label__ = 75; break; } //@line 4769 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $71=$p; //@line 4770 "/root/emscripten/system/lib/dlmalloc.c" + var $72=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4770 "/root/emscripten/system/lib/dlmalloc.c" + var $73=(($71)|0)!=(($72)|0); //@line 4770 "/root/emscripten/system/lib/dlmalloc.c" + if ($73) { __label__ = 11; break; } else { __label__ = 71; break; } //@line 4770 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $75=$prevsize; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $76=$75 >>> 3; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $77=(($76)>>>0) < 32; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($77) { __label__ = 12; break; } else { __label__ = 24; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $79=$p; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $80=(($79+8)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $81=HEAP32[(($80)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $F=$81; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $82=$p; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $83=(($82+12)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $84=HEAP32[(($83)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $B=$84; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $85=$prevsize; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $86=$85 >>> 3; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $I=$86; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $87=$F; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $88=$B; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $89=(($87)|0)==(($88)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($89) { __label__ = 13; break; } else { __label__ = 14; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $91=$I; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $92=1 << $91; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $93=$92 ^ -1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $94=HEAP32[((((__gm_)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $95=$94 & $93; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$95; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 23; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $97=$F; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $98=$I; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $99=$98 << 1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $100=((((__gm_+40)|0)+($99<<2))|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$100; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $102=$101; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $103=(($97)|0)==(($102)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($103) { __label__ = 16; break; } else { __label__ = 15; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $105=$F; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $106=$105; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $107=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $108=(($106)>>>0) >= (($107)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($108) { __label__ = 16; break; } else { var $125 = 0;__label__ = 19; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + var $110=$B; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $111=$I; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $112=$111 << 1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $113=((((__gm_+40)|0)+($112<<2))|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $114=$113; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $115=$114; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $116=(($110)|0)==(($115)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($116) { var $123 = 1;__label__ = 18; break; } else { __label__ = 17; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $118=$B; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $119=$118; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $120=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $121=(($119)>>>0) >= (($120)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $123 = $121;__label__ = 18; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $123; + var $125 = $123;__label__ = 19; break; + case 19: + var $125; + var $126=(($125)&1); + var $127=(($126)==(1)); + var $128=(($127)|0)!=0; + if ($128) { __label__ = 20; break; } else { __label__ = 21; break; } + case 20: + var $130=$B; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $131=$F; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $132=(($131+12)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($132)>>2)]=$130; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $133=$F; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $134=$B; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $135=(($134+8)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($135)>>2)]=$133; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 22; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + __label__ = 23; break; + case 23: + __label__ = 70; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $140=$p; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $141=$140; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $TP=$141; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $142=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $143=(($142+24)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $144=HEAP32[(($143)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $XP=$144; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $145=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $146=(($145+12)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $147=HEAP32[(($146)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $148=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $149=(($147)|0)!=(($148)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($149) { __label__ = 25; break; } else { __label__ = 29; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $151=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $152=(($151+8)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $153=HEAP32[(($152)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $F1=$153; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $154=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $155=(($154+12)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $156=HEAP32[(($155)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $R=$156; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $157=$F1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $158=$157; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $159=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $160=(($158)>>>0) >= (($159)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $161=(($160)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $162=(($161)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $163=(($162)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($163) { __label__ = 26; break; } else { __label__ = 27; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $165=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $166=$F1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $167=(($166+12)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($167)>>2)]=$165; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $168=$F1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $169=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $170=(($169+8)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($170)>>2)]=$168; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 28; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + __label__ = 41; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + var $174=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $175=(($174+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $176=(($175+4)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$176; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $177=HEAP32[(($176)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $R=$177; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $178=(($177)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($178) { __label__ = 31; break; } else { __label__ = 30; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $180=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $181=(($180+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $182=(($181)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$182; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $183=HEAP32[(($182)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $R=$183; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $184=(($183)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($184) { __label__ = 31; break; } else { __label__ = 40; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + __label__ = 32; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $187=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $188=(($187+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $189=(($188+4)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$189; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $190=HEAP32[(($189)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $191=(($190)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($191) { var $199 = 1;__label__ = 34; break; } else { __label__ = 33; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + var $193=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $194=(($193+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $195=(($194)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$195; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $196=HEAP32[(($195)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $197=(($196)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $199 = $197;__label__ = 34; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $199; + if ($199) { __label__ = 35; break; } else { __label__ = 36; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $201=$CP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$201; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $202=HEAP32[(($201)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $R=$202; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 32; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $204=$RP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $205=$204; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $206=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $207=(($205)>>>0) >= (($206)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $208=(($207)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $209=(($208)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $210=(($209)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($210) { __label__ = 37; break; } else { __label__ = 38; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $212=$RP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($212)>>2)]=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 39; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + __label__ = 40; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + __label__ = 41; break; + case 41: + var $217=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $218=(($217)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($218) { __label__ = 42; break; } else { __label__ = 69; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + var $220=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $221=(($220+28)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $222=HEAP32[(($221)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $223=((((__gm_+304)|0)+($222<<2))|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $H=$223; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $224=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $225=$H; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $226=HEAP32[(($225)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $227=(($224)|0)==(($226)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($227) { __label__ = 43; break; } else { __label__ = 46; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + var $229=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $230=$H; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($230)>>2)]=$229; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $231=(($229)|0)==0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($231) { __label__ = 44; break; } else { __label__ = 45; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + var $233=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $234=(($233+28)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $235=HEAP32[(($234)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $236=1 << $235; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $237=$236 ^ -1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $238=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $239=$238 & $237; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+4)|0))>>2)]=$239; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 45; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + __label__ = 53; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $242=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $243=$242; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $244=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $245=(($243)>>>0) >= (($244)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $246=(($245)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $247=(($246)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($247)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($248) { __label__ = 47; break; } else { __label__ = 51; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + var $250=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $251=(($250+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $252=(($251)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $253=HEAP32[(($252)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $254=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $255=(($253)|0)==(($254)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($255) { __label__ = 48; break; } else { __label__ = 49; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + var $257=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $258=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $259=(($258+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $260=(($259)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($260)>>2)]=$257; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 50; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $262=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $263=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $264=(($263+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $265=(($264+4)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($265)>>2)]=$262; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 50; break; + case 50: + __label__ = 52; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + __label__ = 53; break; + case 53: + var $270=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $271=(($270)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($271) { __label__ = 54; break; } else { __label__ = 68; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + var $273=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $274=$273; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $275=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($274)>>>0) >= (($275)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $277=(($276)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $278=(($277)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $279=(($278)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($279) { __label__ = 55; break; } else { __label__ = 66; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 55: + var $281=$XP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $282=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $283=(($282+24)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($283)>>2)]=$281; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $284=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $285=(($284+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $286=(($285)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $287=HEAP32[(($286)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $C0=$287; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $288=(($287)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($288) { __label__ = 56; break; } else { __label__ = 60; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + var $290=$C0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $291=$290; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $292=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $293=(($291)>>>0) >= (($292)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $294=(($293)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $295=(($294)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $296=(($295)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($296) { __label__ = 57; break; } else { __label__ = 58; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + var $298=$C0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $299=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $300=(($299+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $301=(($300)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($301)>>2)]=$298; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $302=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $303=$C0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $304=(($303+24)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($304)>>2)]=$302; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 59; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 58: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 59: + __label__ = 60; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + var $308=$TP; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $309=(($308+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $310=(($309+4)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $311=HEAP32[(($310)>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + $C1=$311; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $312=(($311)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($312) { __label__ = 61; break; } else { __label__ = 65; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + var $314=$C1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $315=$314; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $316=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $317=(($315)>>>0) >= (($316)>>>0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $318=(($317)&1); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $319=(($318)==(1)); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $320=(($319)|0)!=0; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + if ($320) { __label__ = 62; break; } else { __label__ = 63; break; } //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + var $322=$C1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $323=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $324=(($323+16)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $325=(($324+4)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($325)>>2)]=$322; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $326=$R; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $327=$C1; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + var $328=(($327+24)|0); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($328)>>2)]=$326; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 64; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 63: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 64: + __label__ = 65; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 65: + __label__ = 67; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 66: + _abort(); //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 67: + __label__ = 68; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 68: + __label__ = 69; break; //@line 4771 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + __label__ = 70; break; + case 70: + __label__ = 74; break; //@line 4772 "/root/emscripten/system/lib/dlmalloc.c" + case 71: + var $338=$next; //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + var $339=(($338+4)|0); //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + var $340=HEAP32[(($339)>>2)]; //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + var $341=$340 & 3; //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + var $342=(($341)|0)==3; //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + if ($342) { __label__ = 72; break; } else { __label__ = 73; break; } //@line 4773 "/root/emscripten/system/lib/dlmalloc.c" + case 72: + var $344=$psize; //@line 4774 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=$344; //@line 4774 "/root/emscripten/system/lib/dlmalloc.c" + var $345=$next; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $346=(($345+4)|0); //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $347=HEAP32[(($346)>>2)]; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $348=$347 & -2; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($346)>>2)]=$348; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $349=$psize; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $350=$349 | 1; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $351=$p; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $352=(($351+4)|0); //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($352)>>2)]=$350; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $353=$psize; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $354=$p; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $355=$354; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $356=$psize; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $357=(($355+$356)|0); //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $358=$357; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + var $359=(($358)|0); //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($359)>>2)]=$353; //@line 4775 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 196; break; //@line 4776 "/root/emscripten/system/lib/dlmalloc.c" + case 73: + __label__ = 74; break; + case 74: + __label__ = 76; break; //@line 4778 "/root/emscripten/system/lib/dlmalloc.c" + case 75: + __label__ = 195; break; //@line 4780 "/root/emscripten/system/lib/dlmalloc.c" + case 76: + __label__ = 77; break; + case 77: + __label__ = 78; break; //@line 4782 "/root/emscripten/system/lib/dlmalloc.c" + case 78: + var $366=$p; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $367=$366; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$next; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $369=$368; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $370=(($367)>>>0) < (($369)>>>0); //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + if ($370) { __label__ = 79; break; } else { var $378 = 0;__label__ = 80; break; } //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + case 79: + var $372=$next; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $373=(($372+4)|0); //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $374=HEAP32[(($373)>>2)]; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $375=$374 & 1; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $376=(($375)|0)!=0; //@line 4784 "/root/emscripten/system/lib/dlmalloc.c" + var $378 = $376;__label__ = 80; break; + case 80: + var $378; + var $379=(($378)&1); + var $380=(($379)==(1)); + var $381=(($380)|0)!=0; + if ($381) { __label__ = 81; break; } else { __label__ = 193; break; } + case 81: + var $383=$next; //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + var $384=(($383+4)|0); //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + var $385=HEAP32[(($384)>>2)]; //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + var $386=$385 & 2; //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + var $387=(($386)|0)!=0; //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + if ($387) { __label__ = 154; break; } else { __label__ = 82; break; } //@line 4785 "/root/emscripten/system/lib/dlmalloc.c" + case 82: + var $389=$next; //@line 4786 "/root/emscripten/system/lib/dlmalloc.c" + var $390=HEAP32[((((__gm_+24)|0))>>2)]; //@line 4786 "/root/emscripten/system/lib/dlmalloc.c" + var $391=(($389)|0)==(($390)|0); //@line 4786 "/root/emscripten/system/lib/dlmalloc.c" + if ($391) { __label__ = 83; break; } else { __label__ = 88; break; } //@line 4786 "/root/emscripten/system/lib/dlmalloc.c" + case 83: + var $393=$psize; //@line 4787 "/root/emscripten/system/lib/dlmalloc.c" + var $394=HEAP32[((((__gm_+12)|0))>>2)]; //@line 4787 "/root/emscripten/system/lib/dlmalloc.c" + var $395=((($394)+($393))|0); //@line 4787 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+12)|0))>>2)]=$395; //@line 4787 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$395; //@line 4787 "/root/emscripten/system/lib/dlmalloc.c" + var $396=$p; //@line 4788 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+24)|0))>>2)]=$396; //@line 4788 "/root/emscripten/system/lib/dlmalloc.c" + var $397=$tsize; //@line 4789 "/root/emscripten/system/lib/dlmalloc.c" + var $398=$397 | 1; //@line 4789 "/root/emscripten/system/lib/dlmalloc.c" + var $399=$p; //@line 4789 "/root/emscripten/system/lib/dlmalloc.c" + var $400=(($399+4)|0); //@line 4789 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($400)>>2)]=$398; //@line 4789 "/root/emscripten/system/lib/dlmalloc.c" + var $401=$p; //@line 4790 "/root/emscripten/system/lib/dlmalloc.c" + var $402=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4790 "/root/emscripten/system/lib/dlmalloc.c" + var $403=(($401)|0)==(($402)|0); //@line 4790 "/root/emscripten/system/lib/dlmalloc.c" + if ($403) { __label__ = 84; break; } else { __label__ = 85; break; } //@line 4790 "/root/emscripten/system/lib/dlmalloc.c" + case 84: + HEAP32[((((__gm_+20)|0))>>2)]=0; //@line 4791 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=0; //@line 4792 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 85; break; //@line 4793 "/root/emscripten/system/lib/dlmalloc.c" + case 85: + var $406=$tsize; //@line 4794 "/root/emscripten/system/lib/dlmalloc.c" + var $407=HEAP32[((((__gm_+28)|0))>>2)]; //@line 4794 "/root/emscripten/system/lib/dlmalloc.c" + var $408=(($406)>>>0) > (($407)>>>0); //@line 4794 "/root/emscripten/system/lib/dlmalloc.c" + if ($408) { __label__ = 86; break; } else { __label__ = 87; break; } //@line 4794 "/root/emscripten/system/lib/dlmalloc.c" + case 86: + var $410=_sys_trim(__gm_, 0); //@line 4795 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 87; break; //@line 4795 "/root/emscripten/system/lib/dlmalloc.c" + case 87: + __label__ = 196; break; //@line 4796 "/root/emscripten/system/lib/dlmalloc.c" + case 88: + var $413=$next; //@line 4798 "/root/emscripten/system/lib/dlmalloc.c" + var $414=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4798 "/root/emscripten/system/lib/dlmalloc.c" + var $415=(($413)|0)==(($414)|0); //@line 4798 "/root/emscripten/system/lib/dlmalloc.c" + if ($415) { __label__ = 89; break; } else { __label__ = 90; break; } //@line 4798 "/root/emscripten/system/lib/dlmalloc.c" + case 89: + var $417=$psize; //@line 4799 "/root/emscripten/system/lib/dlmalloc.c" + var $418=HEAP32[((((__gm_+8)|0))>>2)]; //@line 4799 "/root/emscripten/system/lib/dlmalloc.c" + var $419=((($418)+($417))|0); //@line 4799 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=$419; //@line 4799 "/root/emscripten/system/lib/dlmalloc.c" + $dsize=$419; //@line 4799 "/root/emscripten/system/lib/dlmalloc.c" + var $420=$p; //@line 4800 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+20)|0))>>2)]=$420; //@line 4800 "/root/emscripten/system/lib/dlmalloc.c" + var $421=$dsize; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $422=$421 | 1; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $423=$p; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $424=(($423+4)|0); //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($424)>>2)]=$422; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $425=$dsize; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $426=$p; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $427=$426; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $428=$dsize; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $429=(($427+$428)|0); //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $430=$429; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + var $431=(($430)|0); //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($431)>>2)]=$425; //@line 4801 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 196; break; //@line 4802 "/root/emscripten/system/lib/dlmalloc.c" + case 90: + var $433=$next; //@line 4805 "/root/emscripten/system/lib/dlmalloc.c" + var $434=(($433+4)|0); //@line 4805 "/root/emscripten/system/lib/dlmalloc.c" + var $435=HEAP32[(($434)>>2)]; //@line 4805 "/root/emscripten/system/lib/dlmalloc.c" + var $436=$435 & -8; //@line 4805 "/root/emscripten/system/lib/dlmalloc.c" + $nsize=$436; //@line 4805 "/root/emscripten/system/lib/dlmalloc.c" + var $437=$nsize; //@line 4806 "/root/emscripten/system/lib/dlmalloc.c" + var $438=$psize; //@line 4806 "/root/emscripten/system/lib/dlmalloc.c" + var $439=((($438)+($437))|0); //@line 4806 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$439; //@line 4806 "/root/emscripten/system/lib/dlmalloc.c" + var $440=$nsize; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $441=$440 >>> 3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $442=(($441)>>>0) < 32; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($442) { __label__ = 91; break; } else { __label__ = 103; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 91: + var $444=$next; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $445=(($444+8)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $446=HEAP32[(($445)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $F2=$446; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $447=$next; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $448=(($447+12)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $449=HEAP32[(($448)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $B3=$449; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $450=$nsize; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $451=$450 >>> 3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $I4=$451; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $452=$F2; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $453=$B3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $454=(($452)|0)==(($453)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($454) { __label__ = 92; break; } else { __label__ = 93; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 92: + var $456=$I4; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $457=1 << $456; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $458=$457 ^ -1; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $459=HEAP32[((((__gm_)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $460=$459 & $458; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$460; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 102; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 93: + var $462=$F2; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $463=$I4; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $464=$463 << 1; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $465=((((__gm_+40)|0)+($464<<2))|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $466=$465; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $467=$466; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $468=(($462)|0)==(($467)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($468) { __label__ = 95; break; } else { __label__ = 94; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 94: + var $470=$F2; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $471=$470; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $472=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $473=(($471)>>>0) >= (($472)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($473) { __label__ = 95; break; } else { var $490 = 0;__label__ = 98; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 95: + var $475=$B3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $476=$I4; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $477=$476 << 1; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $478=((((__gm_+40)|0)+($477<<2))|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $479=$478; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $480=$479; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $481=(($475)|0)==(($480)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($481) { var $488 = 1;__label__ = 97; break; } else { __label__ = 96; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 96: + var $483=$B3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $484=$483; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $485=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $486=(($484)>>>0) >= (($485)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $488 = $486;__label__ = 97; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 97: + var $488; + var $490 = $488;__label__ = 98; break; + case 98: + var $490; + var $491=(($490)&1); + var $492=(($491)==(1)); + var $493=(($492)|0)!=0; + if ($493) { __label__ = 99; break; } else { __label__ = 100; break; } + case 99: + var $495=$B3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $496=$F2; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $497=(($496+12)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($497)>>2)]=$495; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $498=$F2; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $499=$B3; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $500=(($499+8)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($500)>>2)]=$498; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 101; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 100: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 101: + __label__ = 102; break; + case 102: + __label__ = 149; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 103: + var $505=$next; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $506=$505; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $TP5=$506; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $507=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $508=(($507+24)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $509=HEAP32[(($508)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $XP6=$509; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $510=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $511=(($510+12)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $512=HEAP32[(($511)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $513=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $514=(($512)|0)!=(($513)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($514) { __label__ = 104; break; } else { __label__ = 108; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 104: + var $516=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $517=(($516+8)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $518=HEAP32[(($517)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $F8=$518; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $519=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $520=(($519+12)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $521=HEAP32[(($520)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $R7=$521; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $522=$F8; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $523=$522; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $524=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $525=(($523)>>>0) >= (($524)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $526=(($525)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $527=(($526)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $528=(($527)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($528) { __label__ = 105; break; } else { __label__ = 106; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 105: + var $530=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $531=$F8; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $532=(($531+12)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($532)>>2)]=$530; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $533=$F8; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $534=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $535=(($534+8)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($535)>>2)]=$533; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 107; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 106: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 107: + __label__ = 120; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 108: + var $539=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $540=(($539+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $541=(($540+4)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $RP9=$541; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $542=HEAP32[(($541)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $R7=$542; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $543=(($542)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($543) { __label__ = 110; break; } else { __label__ = 109; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 109: + var $545=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $546=(($545+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $547=(($546)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $RP9=$547; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $548=HEAP32[(($547)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $R7=$548; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $549=(($548)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($549) { __label__ = 110; break; } else { __label__ = 119; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 110: + __label__ = 111; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 111: + var $552=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $553=(($552+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $554=(($553+4)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $CP10=$554; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $555=HEAP32[(($554)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $556=(($555)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($556) { var $564 = 1;__label__ = 113; break; } else { __label__ = 112; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 112: + var $558=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $559=(($558+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $560=(($559)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $CP10=$560; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $561=HEAP32[(($560)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $562=(($561)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $564 = $562;__label__ = 113; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 113: + var $564; + if ($564) { __label__ = 114; break; } else { __label__ = 115; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 114: + var $566=$CP10; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $RP9=$566; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $567=HEAP32[(($566)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $R7=$567; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 111; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 115: + var $569=$RP9; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $570=$569; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $571=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $572=(($570)>>>0) >= (($571)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $573=(($572)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $574=(($573)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $575=(($574)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($575) { __label__ = 116; break; } else { __label__ = 117; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 116: + var $577=$RP9; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($577)>>2)]=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 118; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 117: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 118: + __label__ = 119; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 119: + __label__ = 120; break; + case 120: + var $582=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $583=(($582)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($583) { __label__ = 121; break; } else { __label__ = 148; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 121: + var $585=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $586=(($585+28)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $587=HEAP32[(($586)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $588=((((__gm_+304)|0)+($587<<2))|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $H11=$588; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $589=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $590=$H11; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $591=HEAP32[(($590)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $592=(($589)|0)==(($591)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($592) { __label__ = 122; break; } else { __label__ = 125; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 122: + var $594=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $595=$H11; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($595)>>2)]=$594; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $596=(($594)|0)==0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($596) { __label__ = 123; break; } else { __label__ = 124; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 123: + var $598=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $599=(($598+28)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $600=HEAP32[(($599)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $601=1 << $600; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $602=$601 ^ -1; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $603=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $604=$603 & $602; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+4)|0))>>2)]=$604; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 124; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 124: + __label__ = 132; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 125: + var $607=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $608=$607; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $609=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $610=(($608)>>>0) >= (($609)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $611=(($610)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $612=(($611)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $613=(($612)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($613) { __label__ = 126; break; } else { __label__ = 130; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 126: + var $615=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $616=(($615+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $617=(($616)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $618=HEAP32[(($617)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $619=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $620=(($618)|0)==(($619)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($620) { __label__ = 127; break; } else { __label__ = 128; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 127: + var $622=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $623=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $624=(($623+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $625=(($624)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($625)>>2)]=$622; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 129; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 128: + var $627=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $628=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $629=(($628+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $630=(($629+4)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($630)>>2)]=$627; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 129; break; + case 129: + __label__ = 131; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 130: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 131: + __label__ = 132; break; + case 132: + var $635=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $636=(($635)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($636) { __label__ = 133; break; } else { __label__ = 147; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 133: + var $638=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $639=$638; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $640=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $641=(($639)>>>0) >= (($640)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $642=(($641)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $643=(($642)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $644=(($643)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($644) { __label__ = 134; break; } else { __label__ = 145; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 134: + var $646=$XP6; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $647=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $648=(($647+24)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($648)>>2)]=$646; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $649=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $650=(($649+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $651=(($650)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $652=HEAP32[(($651)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $C012=$652; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $653=(($652)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($653) { __label__ = 135; break; } else { __label__ = 139; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 135: + var $655=$C012; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $656=$655; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $657=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $658=(($656)>>>0) >= (($657)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $659=(($658)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $660=(($659)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $661=(($660)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($661) { __label__ = 136; break; } else { __label__ = 137; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 136: + var $663=$C012; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $664=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $665=(($664+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $666=(($665)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($666)>>2)]=$663; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $667=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $668=$C012; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $669=(($668+24)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($669)>>2)]=$667; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 138; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 137: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 138: + __label__ = 139; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 139: + var $673=$TP5; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $674=(($673+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $675=(($674+4)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $676=HEAP32[(($675)>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + $C113=$676; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $677=(($676)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($677) { __label__ = 140; break; } else { __label__ = 144; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 140: + var $679=$C113; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $680=$679; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $681=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $682=(($680)>>>0) >= (($681)>>>0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $683=(($682)&1); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $684=(($683)==(1)); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $685=(($684)|0)!=0; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + if ($685) { __label__ = 141; break; } else { __label__ = 142; break; } //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 141: + var $687=$C113; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $688=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $689=(($688+16)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $690=(($689+4)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($690)>>2)]=$687; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $691=$R7; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $692=$C113; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + var $693=(($692+24)|0); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($693)>>2)]=$691; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 143; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 142: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 143: + __label__ = 144; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 144: + __label__ = 146; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 145: + _abort(); //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 146: + __label__ = 147; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 147: + __label__ = 148; break; //@line 4807 "/root/emscripten/system/lib/dlmalloc.c" + case 148: + __label__ = 149; break; + case 149: + var $702=$psize; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $703=$702 | 1; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $704=$p; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $705=(($704+4)|0); //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($705)>>2)]=$703; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $706=$psize; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $707=$p; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $708=$707; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $709=$psize; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $710=(($708+$709)|0); //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $711=$710; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $712=(($711)|0); //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($712)>>2)]=$706; //@line 4808 "/root/emscripten/system/lib/dlmalloc.c" + var $713=$p; //@line 4809 "/root/emscripten/system/lib/dlmalloc.c" + var $714=HEAP32[((((__gm_+20)|0))>>2)]; //@line 4809 "/root/emscripten/system/lib/dlmalloc.c" + var $715=(($713)|0)==(($714)|0); //@line 4809 "/root/emscripten/system/lib/dlmalloc.c" + if ($715) { __label__ = 150; break; } else { __label__ = 151; break; } //@line 4809 "/root/emscripten/system/lib/dlmalloc.c" + case 150: + var $717=$psize; //@line 4810 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+8)|0))>>2)]=$717; //@line 4810 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 196; break; //@line 4811 "/root/emscripten/system/lib/dlmalloc.c" + case 151: + __label__ = 152; break; + case 152: + __label__ = 153; break; + case 153: + __label__ = 155; break; //@line 4814 "/root/emscripten/system/lib/dlmalloc.c" + case 154: + var $722=$next; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $723=(($722+4)|0); //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $724=HEAP32[(($723)>>2)]; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $725=$724 & -2; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($723)>>2)]=$725; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $726=$psize; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $727=$726 | 1; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $728=$p; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $729=(($728+4)|0); //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($729)>>2)]=$727; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $730=$psize; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $731=$p; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $732=$731; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $733=$psize; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $734=(($732+$733)|0); //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $735=$734; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + var $736=(($735)|0); //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($736)>>2)]=$730; //@line 4816 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 155; break; + case 155: + var $738=$psize; //@line 4818 "/root/emscripten/system/lib/dlmalloc.c" + var $739=$738 >>> 3; //@line 4818 "/root/emscripten/system/lib/dlmalloc.c" + var $740=(($739)>>>0) < 32; //@line 4818 "/root/emscripten/system/lib/dlmalloc.c" + if ($740) { __label__ = 156; break; } else { __label__ = 163; break; } //@line 4818 "/root/emscripten/system/lib/dlmalloc.c" + case 156: + var $742=$psize; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $743=$742 >>> 3; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + $I14=$743; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $744=$I14; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $745=$744 << 1; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $746=((((__gm_+40)|0)+($745<<2))|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $747=$746; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $748=$747; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + $B15=$748; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $749=$B15; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + $F16=$749; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $750=HEAP32[((((__gm_)|0))>>2)]; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $751=$I14; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $752=1 << $751; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $753=$750 & $752; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $754=(($753)|0)!=0; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + if ($754) { __label__ = 158; break; } else { __label__ = 157; break; } //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + case 157: + var $756=$I14; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $757=1 << $756; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $758=HEAP32[((((__gm_)|0))>>2)]; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $759=$758 | $757; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_)|0))>>2)]=$759; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 162; break; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + case 158: + var $761=$B15; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $762=(($761+8)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $763=HEAP32[(($762)>>2)]; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $764=$763; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $765=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $766=(($764)>>>0) >= (($765)>>>0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $767=(($766)&1); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $768=(($767)==(1)); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $769=(($768)|0)!=0; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + if ($769) { __label__ = 159; break; } else { __label__ = 160; break; } //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + case 159: + var $771=$B15; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $772=(($771+8)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $773=HEAP32[(($772)>>2)]; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + $F16=$773; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 161; break; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + case 160: + _abort(); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + case 161: + __label__ = 162; break; + case 162: + var $777=$p; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $778=$B15; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $779=(($778+8)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($779)>>2)]=$777; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $780=$p; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $781=$F16; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $782=(($781+12)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($782)>>2)]=$780; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $783=$F16; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $784=$p; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $785=(($784+8)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($785)>>2)]=$783; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $786=$B15; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $787=$p; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + var $788=(($787+12)|0); //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($788)>>2)]=$786; //@line 4819 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 192; break; //@line 4821 "/root/emscripten/system/lib/dlmalloc.c" + case 163: + var $790=$p; //@line 4823 "/root/emscripten/system/lib/dlmalloc.c" + var $791=$790; //@line 4823 "/root/emscripten/system/lib/dlmalloc.c" + $tp=$791; //@line 4823 "/root/emscripten/system/lib/dlmalloc.c" + var $792=$psize; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $793=$792 >>> 8; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $X=$793; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $794=$X; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $795=(($794)|0)==0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($795) { __label__ = 164; break; } else { __label__ = 165; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 164: + $I18=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 169; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 165: + var $798=$X; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $799=(($798)>>>0) > 65535; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($799) { __label__ = 166; break; } else { __label__ = 167; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 166: + $I18=31; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 168; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 167: + var $802=$X; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$802; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $803=$Y; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $804=((($803)-(256))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $805=$804 >>> 16; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $806=$805 & 8; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $N=$806; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $807=$N; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $808=$Y; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $809=$808 << $807; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$809; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $810=((($809)-(4096))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $811=$810 >>> 16; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $812=$811 & 4; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $K=$812; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $813=$K; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $814=$N; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $815=((($814)+($813))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $N=$815; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $816=$K; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $817=$Y; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $818=$817 << $816; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$818; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $819=((($818)-(16384))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $820=$819 >>> 16; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $821=$820 & 2; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $K=$821; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $822=$N; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $823=((($822)+($821))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $N=$823; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $824=$N; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $825=(((14)-($824))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $826=$K; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $827=$Y; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $828=$827 << $826; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$828; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $829=$828 >>> 15; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $830=((($825)+($829))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $K=$830; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $831=$K; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $832=$831 << 1; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $833=$psize; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $834=$K; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $835=((($834)+(7))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $836=$833 >>> (($835)>>>0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $837=$836 & 1; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $838=((($832)+($837))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $I18=$838; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 168; break; + case 168: + __label__ = 169; break; + case 169: + var $841=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $842=((((__gm_+304)|0)+($841<<2))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $H17=$842; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $843=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $844=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $845=(($844+28)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($845)>>2)]=$843; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $846=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $847=(($846+16)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $848=(($847+4)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($848)>>2)]=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $849=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $850=(($849+16)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $851=(($850)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($851)>>2)]=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $852=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $853=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $854=1 << $853; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $855=$852 & $854; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $856=(($855)|0)!=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($856) { __label__ = 171; break; } else { __label__ = 170; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 170: + var $858=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $859=1 << $858; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $860=HEAP32[((((__gm_+4)|0))>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $861=$860 | $859; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+4)|0))>>2)]=$861; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $862=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $863=$H17; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($863)>>2)]=$862; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $864=$H17; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $865=$864; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $866=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $867=(($866+24)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($867)>>2)]=$865; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $868=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $869=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $870=(($869+12)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($870)>>2)]=$868; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $871=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $872=(($871+8)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($872)>>2)]=$868; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 189; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 171: + var $874=$H17; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $875=HEAP32[(($874)>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $T=$875; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $876=$psize; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $877=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $878=(($877)|0)==31; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($878) { __label__ = 172; break; } else { __label__ = 173; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 172: + var $887 = 0;__label__ = 174; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 173: + var $881=$I18; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $882=$881 >>> 1; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $883=((($882)+(8))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $884=((($883)-(2))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $885=(((31)-($884))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $887 = $885;__label__ = 174; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 174: + var $887; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $888=$876 << $887; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $K19=$888; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 175; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 175: + var $890=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $891=(($890+4)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $892=HEAP32[(($891)>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $893=$892 & -8; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $894=$psize; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $895=(($893)|0)!=(($894)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($895) { __label__ = 176; break; } else { __label__ = 182; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 176: + var $897=$K19; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $898=$897 >>> 31; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $899=$898 & 1; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $900=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $901=(($900+16)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $902=(($901+($899<<2))|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $C=$902; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $903=$K19; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $904=$903 << 1; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $K19=$904; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $905=$C; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $906=HEAP32[(($905)>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $907=(($906)|0)!=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($907) { __label__ = 177; break; } else { __label__ = 178; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 177: + var $909=$C; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $910=HEAP32[(($909)>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $T=$910; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 181; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 178: + var $912=$C; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $913=$912; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $914=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $915=(($913)>>>0) >= (($914)>>>0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $916=(($915)&1); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $917=(($916)==(1)); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $918=(($917)|0)!=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($918) { __label__ = 179; break; } else { __label__ = 180; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 179: + var $920=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $921=$C; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($921)>>2)]=$920; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $922=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $923=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $924=(($923+24)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($924)>>2)]=$922; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $925=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $926=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $927=(($926+12)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($927)>>2)]=$925; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $928=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $929=(($928+8)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($929)>>2)]=$925; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 188; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 180: + _abort(); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 181: + __label__ = 187; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 182: + var $933=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $934=(($933+8)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $935=HEAP32[(($934)>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + $F20=$935; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $936=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $937=$936; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $938=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $939=(($937)>>>0) >= (($938)>>>0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + if ($939) { __label__ = 183; break; } else { var $946 = 0;__label__ = 184; break; } //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 183: + var $941=$F20; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $942=$941; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $943=HEAP32[((((__gm_+16)|0))>>2)]; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $944=(($942)>>>0) >= (($943)>>>0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $946 = $944;__label__ = 184; break; + case 184: + var $946; + var $947=(($946)&1); + var $948=(($947)==(1)); + var $949=(($948)|0)!=0; + if ($949) { __label__ = 185; break; } else { __label__ = 186; break; } + case 185: + var $951=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $952=$F20; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $953=(($952+12)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($953)>>2)]=$951; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $954=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $955=(($954+8)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($955)>>2)]=$951; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $956=$F20; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $957=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $958=(($957+8)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($958)>>2)]=$956; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $959=$T; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $960=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $961=(($960+12)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($961)>>2)]=$959; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $962=$tp; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + var $963=(($962+24)|0); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($963)>>2)]=0; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 188; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 186: + _abort(); //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 187: + __label__ = 175; break; //@line 4824 "/root/emscripten/system/lib/dlmalloc.c" + case 188: + __label__ = 189; break; + case 189: + var $968=HEAP32[((((__gm_+32)|0))>>2)]; //@line 4826 "/root/emscripten/system/lib/dlmalloc.c" + var $969=((($968)-(1))|0); //@line 4826 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+32)|0))>>2)]=$969; //@line 4826 "/root/emscripten/system/lib/dlmalloc.c" + var $970=(($969)|0)==0; //@line 4826 "/root/emscripten/system/lib/dlmalloc.c" + if ($970) { __label__ = 190; break; } else { __label__ = 191; break; } //@line 4826 "/root/emscripten/system/lib/dlmalloc.c" + case 190: + var $972=_release_unused_segments(__gm_); //@line 4827 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 191; break; //@line 4827 "/root/emscripten/system/lib/dlmalloc.c" + case 191: + __label__ = 192; break; + case 192: + __label__ = 196; break; //@line 4829 "/root/emscripten/system/lib/dlmalloc.c" + case 193: + __label__ = 194; break; //@line 4831 "/root/emscripten/system/lib/dlmalloc.c" + case 194: + __label__ = 195; break; //@line 4831 "/root/emscripten/system/lib/dlmalloc.c" + case 195: + _abort(); //@line 4833 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4833 "/root/emscripten/system/lib/dlmalloc.c" + case 196: + __label__ = 197; break; //@line 4837 "/root/emscripten/system/lib/dlmalloc.c" + case 197: + ; + return; //@line 4841 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +Module["_free"] = _free;_free["X"]=1; + +function _sys_trim($m, $pad) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $released; + var $unit; + var $extra; + var $sp; + var $old_br; + var $rel_br; + var $new_br; + $1=$m; + $2=$pad; + $released=0; //@line 4126 "/root/emscripten/system/lib/dlmalloc.c" + var $3=HEAP32[((((_mparams)|0))>>2)]; //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + var $4=(($3)|0)!=0; //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + if ($4) { var $9 = 1;__label__ = 4; break; } else { __label__ = 3; break; } //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $6=_init_mparams(); //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + var $7=(($6)|0)!=0; //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + var $9 = $7;__label__ = 4; break; //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $9; + var $10=(($9)&1); //@line 4127 "/root/emscripten/system/lib/dlmalloc.c" + var $11=$2; //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + var $12=(($11)>>>0) < 4294967232; //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + if ($12) { __label__ = 5; break; } else { __label__ = 26; break; } //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $14=$1; //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + var $15=(($14+24)|0); //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + var $16=HEAP32[(($15)>>2)]; //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + var $17=(($16)|0)!=0; //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + if ($17) { __label__ = 6; break; } else { __label__ = 26; break; } //@line 4128 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $19=$2; //@line 4129 "/root/emscripten/system/lib/dlmalloc.c" + var $20=((($19)+(40))|0); //@line 4129 "/root/emscripten/system/lib/dlmalloc.c" + $2=$20; //@line 4129 "/root/emscripten/system/lib/dlmalloc.c" + var $21=$1; //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + var $22=(($21+12)|0); //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + var $23=HEAP32[(($22)>>2)]; //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + var $24=$2; //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + var $25=(($23)>>>0) > (($24)>>>0); //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + if ($25) { __label__ = 7; break; } else { __label__ = 22; break; } //@line 4131 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $27=HEAP32[((((_mparams+8)|0))>>2)]; //@line 4133 "/root/emscripten/system/lib/dlmalloc.c" + $unit=$27; //@line 4133 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$1; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $29=(($28+12)|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $30=HEAP32[(($29)>>2)]; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $31=$2; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $32=((($30)-($31))|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$unit; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $34=((($33)-(1))|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $35=((($32)+($34))|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$unit; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $37=Math.floor(((($35)>>>0))/((($36)>>>0))); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $38=((($37)-(1))|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $39=$unit; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $40=((($38)*($39))|0); //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + $extra=$40; //@line 4135 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$1; //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$1; //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $43=(($42+24)|0); //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $44=HEAP32[(($43)>>2)]; //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$44; //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $46=_segment_holding($41, $45); //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$46; //@line 4136 "/root/emscripten/system/lib/dlmalloc.c" + var $47=$sp; //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + var $48=(($47+12)|0); //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + var $49=HEAP32[(($48)>>2)]; //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$49 & 8; //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + var $51=(($50)|0)!=0; //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + if ($51) { __label__ = 19; break; } else { __label__ = 8; break; } //@line 4138 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $53=$sp; //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + var $54=(($53+12)|0); //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + var $55=HEAP32[(($54)>>2)]; //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$55 & 0; //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56)|0)!=0; //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + if ($57) { __label__ = 9; break; } else { __label__ = 10; break; } //@line 4139 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + __label__ = 18; break; //@line 4151 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $60=$extra; //@line 4153 "/root/emscripten/system/lib/dlmalloc.c" + var $61=(($60)>>>0) >= 2147483647; //@line 4153 "/root/emscripten/system/lib/dlmalloc.c" + if ($61) { __label__ = 11; break; } else { __label__ = 12; break; } //@line 4153 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $63=$unit; //@line 4154 "/root/emscripten/system/lib/dlmalloc.c" + var $64=(((-2147483648)-($63))|0); //@line 4154 "/root/emscripten/system/lib/dlmalloc.c" + $extra=$64; //@line 4154 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 12; break; //@line 4154 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $66=_sbrk(0); //@line 4158 "/root/emscripten/system/lib/dlmalloc.c" + $old_br=$66; //@line 4158 "/root/emscripten/system/lib/dlmalloc.c" + var $67=$old_br; //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $68=$sp; //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $69=(($68)|0); //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $70=HEAP32[(($69)>>2)]; //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $71=$sp; //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $72=(($71+4)|0); //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $73=HEAP32[(($72)>>2)]; //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $74=(($70+$73)|0); //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + var $75=(($67)|0)==(($74)|0); //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + if ($75) { __label__ = 13; break; } else { __label__ = 17; break; } //@line 4159 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $77=$extra; //@line 4160 "/root/emscripten/system/lib/dlmalloc.c" + var $78=(((-$77))|0); //@line 4160 "/root/emscripten/system/lib/dlmalloc.c" + var $79=_sbrk($78); //@line 4160 "/root/emscripten/system/lib/dlmalloc.c" + $rel_br=$79; //@line 4160 "/root/emscripten/system/lib/dlmalloc.c" + var $80=_sbrk(0); //@line 4161 "/root/emscripten/system/lib/dlmalloc.c" + $new_br=$80; //@line 4161 "/root/emscripten/system/lib/dlmalloc.c" + var $81=$rel_br; //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + var $82=(($81)|0)!=-1; //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + if ($82) { __label__ = 14; break; } else { __label__ = 16; break; } //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $84=$new_br; //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + var $85=$old_br; //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + var $86=(($84)>>>0) < (($85)>>>0); //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + if ($86) { __label__ = 15; break; } else { __label__ = 16; break; } //@line 4162 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $88=$old_br; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + var $89=$new_br; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + var $90=$88; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + var $91=$89; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + var $92=((($90)-($91))|0); //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + $released=$92; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 16; break; //@line 4163 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + __label__ = 17; break; //@line 4164 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + __label__ = 18; break; + case 18: + __label__ = 19; break; //@line 4168 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $97=$released; //@line 4170 "/root/emscripten/system/lib/dlmalloc.c" + var $98=(($97)|0)!=0; //@line 4170 "/root/emscripten/system/lib/dlmalloc.c" + if ($98) { __label__ = 20; break; } else { __label__ = 21; break; } //@line 4170 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + var $100=$released; //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$sp; //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + var $102=(($101+4)|0); //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + var $103=HEAP32[(($102)>>2)]; //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + var $104=((($103)-($100))|0); //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($102)>>2)]=$104; //@line 4171 "/root/emscripten/system/lib/dlmalloc.c" + var $105=$released; //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + var $106=$1; //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + var $107=(($106+432)|0); //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + var $108=HEAP32[(($107)>>2)]; //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + var $109=((($108)-($105))|0); //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($107)>>2)]=$109; //@line 4172 "/root/emscripten/system/lib/dlmalloc.c" + var $110=$1; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $111=$1; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $112=(($111+24)|0); //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $113=HEAP32[(($112)>>2)]; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $114=$1; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $115=(($114+12)|0); //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $116=HEAP32[(($115)>>2)]; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $117=$released; //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + var $118=((($116)-($117))|0); //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + _init_top($110, $113, $118); //@line 4173 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 21; break; //@line 4175 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + __label__ = 22; break; //@line 4176 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + var $121=$released; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $122=(($121)|0)==0; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + if ($122) { __label__ = 23; break; } else { __label__ = 25; break; } //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + var $124=$1; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $125=(($124+12)|0); //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $126=HEAP32[(($125)>>2)]; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $127=$1; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $128=(($127+28)|0); //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $129=HEAP32[(($128)>>2)]; //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + var $130=(($126)>>>0) > (($129)>>>0); //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + if ($130) { __label__ = 24; break; } else { __label__ = 25; break; } //@line 4183 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $132=$1; //@line 4184 "/root/emscripten/system/lib/dlmalloc.c" + var $133=(($132+28)|0); //@line 4184 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($133)>>2)]=-1; //@line 4184 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 25; break; //@line 4184 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + __label__ = 26; break; //@line 4185 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $136=$released; //@line 4187 "/root/emscripten/system/lib/dlmalloc.c" + var $137=(($136)|0)!=0; //@line 4187 "/root/emscripten/system/lib/dlmalloc.c" + var $138=$137 ? 1 : 0; //@line 4187 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $138; //@line 4187 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_sys_trim["X"]=1; + +function _segment_holding($m, $addr) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $sp; + $2=$m; + $3=$addr; + var $4=$2; //@line 2562 "/root/emscripten/system/lib/dlmalloc.c" + var $5=(($4+444)|0); //@line 2562 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$5; //@line 2562 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 2563 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $7=$3; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$sp; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(($8)|0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $10=HEAP32[(($9)>>2)]; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $11=(($7)>>>0) >= (($10)>>>0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + if ($11) { __label__ = 4; break; } else { __label__ = 6; break; } //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $13=$3; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $14=$sp; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $15=(($14)|0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $16=HEAP32[(($15)>>2)]; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $17=$sp; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $18=(($17+4)|0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $19=HEAP32[(($18)>>2)]; //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $20=(($16+$19)|0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + var $21=(($13)>>>0) < (($20)>>>0); //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } //@line 2564 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $23=$sp; //@line 2565 "/root/emscripten/system/lib/dlmalloc.c" + $1=$23; //@line 2565 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 9; break; //@line 2565 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $25=$sp; //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + var $26=(($25+8)|0); //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + var $27=HEAP32[(($26)>>2)]; //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$27; //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + var $28=(($27)|0)==0; //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + if ($28) { __label__ = 7; break; } else { __label__ = 8; break; } //@line 2566 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + $1=0; //@line 2567 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 9; break; //@line 2567 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + __label__ = 3; break; //@line 2568 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $32=$1; //@line 2569 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $32; //@line 2569 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} + + +function _release_unused_segments($m) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $released; + var $nsegs; + var $pred; + var $sp; + var $base; + var $size; + var $next; + var $p; + var $psize; + var $tp; + var $XP; + var $R; + var $F; + var $RP; + var $CP; + var $H; + var $C0; + var $C1; + var $H1; + var $I; + var $X; + var $Y; + var $N; + var $K; + var $T; + var $K2; + var $C; + var $F3; + $1=$m; + $released=0; //@line 4079 "/root/emscripten/system/lib/dlmalloc.c" + $nsegs=0; //@line 4080 "/root/emscripten/system/lib/dlmalloc.c" + var $2=$1; //@line 4081 "/root/emscripten/system/lib/dlmalloc.c" + var $3=(($2+444)|0); //@line 4081 "/root/emscripten/system/lib/dlmalloc.c" + $pred=$3; //@line 4081 "/root/emscripten/system/lib/dlmalloc.c" + var $4=$pred; //@line 4082 "/root/emscripten/system/lib/dlmalloc.c" + var $5=(($4+8)|0); //@line 4082 "/root/emscripten/system/lib/dlmalloc.c" + var $6=HEAP32[(($5)>>2)]; //@line 4082 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$6; //@line 4082 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 4083 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $8=$sp; //@line 4083 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(($8)|0)!=0; //@line 4083 "/root/emscripten/system/lib/dlmalloc.c" + if ($9) { __label__ = 4; break; } else { __label__ = 88; break; } //@line 4083 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $11=$sp; //@line 4084 "/root/emscripten/system/lib/dlmalloc.c" + var $12=(($11)|0); //@line 4084 "/root/emscripten/system/lib/dlmalloc.c" + var $13=HEAP32[(($12)>>2)]; //@line 4084 "/root/emscripten/system/lib/dlmalloc.c" + $base=$13; //@line 4084 "/root/emscripten/system/lib/dlmalloc.c" + var $14=$sp; //@line 4085 "/root/emscripten/system/lib/dlmalloc.c" + var $15=(($14+4)|0); //@line 4085 "/root/emscripten/system/lib/dlmalloc.c" + var $16=HEAP32[(($15)>>2)]; //@line 4085 "/root/emscripten/system/lib/dlmalloc.c" + $size=$16; //@line 4085 "/root/emscripten/system/lib/dlmalloc.c" + var $17=$sp; //@line 4086 "/root/emscripten/system/lib/dlmalloc.c" + var $18=(($17+8)|0); //@line 4086 "/root/emscripten/system/lib/dlmalloc.c" + var $19=HEAP32[(($18)>>2)]; //@line 4086 "/root/emscripten/system/lib/dlmalloc.c" + $next=$19; //@line 4086 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$nsegs; //@line 4087 "/root/emscripten/system/lib/dlmalloc.c" + var $21=((($20)+(1))|0); //@line 4087 "/root/emscripten/system/lib/dlmalloc.c" + $nsegs=$21; //@line 4087 "/root/emscripten/system/lib/dlmalloc.c" + var $22=$sp; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $23=(($22+12)|0); //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $24=HEAP32[(($23)>>2)]; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$24 & 0; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $26=(($25)|0)!=0; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + if ($26) { __label__ = 5; break; } else { __label__ = 87; break; } //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $28=$sp; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $29=(($28+12)|0); //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $30=HEAP32[(($29)>>2)]; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $31=$30 & 8; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + var $32=(($31)|0)!=0; //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + if ($32) { __label__ = 87; break; } else { __label__ = 6; break; } //@line 4088 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $34=$base; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $35=$base; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $36=(($35+8)|0); //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$36; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $38=$37 & 7; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $39=(($38)|0)==0; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + if ($39) { __label__ = 7; break; } else { __label__ = 8; break; } //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $49 = 0;__label__ = 9; break; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $42=$base; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $43=(($42+8)|0); //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $44=$43; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$44 & 7; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $46=(((8)-($45))|0); //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $47=$46 & 7; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $49 = $47;__label__ = 9; break; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $49; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $50=(($34+$49)|0); //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $51=$50; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + $p=$51; //@line 4089 "/root/emscripten/system/lib/dlmalloc.c" + var $52=$p; //@line 4090 "/root/emscripten/system/lib/dlmalloc.c" + var $53=(($52+4)|0); //@line 4090 "/root/emscripten/system/lib/dlmalloc.c" + var $54=HEAP32[(($53)>>2)]; //@line 4090 "/root/emscripten/system/lib/dlmalloc.c" + var $55=$54 & -8; //@line 4090 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$55; //@line 4090 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$p; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56+4)|0); //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $58=HEAP32[(($57)>>2)]; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $59=$58 & 3; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $60=(($59)|0)!=1; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + if ($60) { __label__ = 86; break; } else { __label__ = 10; break; } //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $62=$p; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$62; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $64=$psize; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $65=(($63+$64)|0); //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $66=$base; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $67=$size; //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $68=(($66+$67)|0); //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $69=((($68)-(40))|0); //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + var $70=(($65)>>>0) >= (($69)>>>0); //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + if ($70) { __label__ = 11; break; } else { __label__ = 86; break; } //@line 4092 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $72=$p; //@line 4093 "/root/emscripten/system/lib/dlmalloc.c" + var $73=$72; //@line 4093 "/root/emscripten/system/lib/dlmalloc.c" + $tp=$73; //@line 4093 "/root/emscripten/system/lib/dlmalloc.c" + var $74=$p; //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + var $75=$1; //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + var $76=(($75+20)|0); //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + var $77=HEAP32[(($76)>>2)]; //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + var $78=(($74)|0)==(($77)|0); //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + if ($78) { __label__ = 12; break; } else { __label__ = 13; break; } //@line 4095 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $80=$1; //@line 4096 "/root/emscripten/system/lib/dlmalloc.c" + var $81=(($80+20)|0); //@line 4096 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($81)>>2)]=0; //@line 4096 "/root/emscripten/system/lib/dlmalloc.c" + var $82=$1; //@line 4097 "/root/emscripten/system/lib/dlmalloc.c" + var $83=(($82+8)|0); //@line 4097 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($83)>>2)]=0; //@line 4097 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 59; break; //@line 4098 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $85=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $86=(($85+24)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $87=HEAP32[(($86)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $XP=$87; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $88=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $89=(($88+12)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $90=HEAP32[(($89)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $91=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $92=(($90)|0)!=(($91)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($92) { __label__ = 14; break; } else { __label__ = 18; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $94=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $95=(($94+8)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $96=HEAP32[(($95)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $F=$96; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $97=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $98=(($97+12)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $99=HEAP32[(($98)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $R=$99; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $100=$F; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$100; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $102=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $103=(($102+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $104=HEAP32[(($103)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $105=(($101)>>>0) >= (($104)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $106=(($105)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $107=(($106)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $108=(($107)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($108) { __label__ = 15; break; } else { __label__ = 16; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $110=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $111=$F; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $112=(($111+12)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($112)>>2)]=$110; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $113=$F; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $114=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $115=(($114+8)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($115)>>2)]=$113; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 17; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + __label__ = 30; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $119=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $120=(($119+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $121=(($120+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$121; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $122=HEAP32[(($121)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $R=$122; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $123=(($122)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($123) { __label__ = 20; break; } else { __label__ = 19; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $125=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $126=(($125+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $127=(($126)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$127; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $128=HEAP32[(($127)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $R=$128; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $129=(($128)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($129) { __label__ = 20; break; } else { __label__ = 29; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + __label__ = 21; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 21: + var $132=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $133=(($132+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $134=(($133+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$134; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $135=HEAP32[(($134)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $136=(($135)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($136) { var $144 = 1;__label__ = 23; break; } else { __label__ = 22; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + var $138=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $139=(($138+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $140=(($139)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$140; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $141=HEAP32[(($140)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $142=(($141)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $144 = $142;__label__ = 23; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + var $144; + if ($144) { __label__ = 24; break; } else { __label__ = 25; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $146=$CP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$146; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $147=HEAP32[(($146)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $R=$147; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 21; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + var $149=$RP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $150=$149; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $151=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $152=(($151+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $153=HEAP32[(($152)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $154=(($150)>>>0) >= (($153)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $155=(($154)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $156=(($155)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $157=(($156)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($157) { __label__ = 26; break; } else { __label__ = 27; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $159=$RP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($159)>>2)]=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 28; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + __label__ = 29; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + __label__ = 30; break; + case 30: + var $164=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $165=(($164)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($165) { __label__ = 31; break; } else { __label__ = 58; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $167=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $168=(($167+28)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $169=HEAP32[(($168)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $170=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $171=(($170+304)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $172=(($171+($169<<2))|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $H=$172; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $173=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $174=$H; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $175=HEAP32[(($174)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $176=(($173)|0)==(($175)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($176) { __label__ = 32; break; } else { __label__ = 35; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $178=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $179=$H; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($179)>>2)]=$178; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $180=(($178)|0)==0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($180) { __label__ = 33; break; } else { __label__ = 34; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + var $182=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $183=(($182+28)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $184=HEAP32[(($183)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $185=1 << $184; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $186=$185 ^ -1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $187=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $188=(($187+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $189=HEAP32[(($188)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $190=$189 & $186; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($188)>>2)]=$190; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 34; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + __label__ = 42; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $193=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $194=$193; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $195=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $196=(($195+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $197=HEAP32[(($196)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $198=(($194)>>>0) >= (($197)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $199=(($198)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $200=(($199)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $201=(($200)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($201) { __label__ = 36; break; } else { __label__ = 40; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $203=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $204=(($203+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $205=(($204)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $206=HEAP32[(($205)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $207=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $208=(($206)|0)==(($207)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($208) { __label__ = 37; break; } else { __label__ = 38; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $210=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $211=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $212=(($211+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $213=(($212)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($213)>>2)]=$210; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 39; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $215=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $216=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $217=(($216+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $218=(($217+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($218)>>2)]=$215; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 39; break; + case 39: + __label__ = 41; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 41: + __label__ = 42; break; + case 42: + var $223=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $224=(($223)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($224) { __label__ = 43; break; } else { __label__ = 57; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 43: + var $226=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $227=$226; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $228=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $229=(($228+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $230=HEAP32[(($229)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $231=(($227)>>>0) >= (($230)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $232=(($231)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $233=(($232)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $234=(($233)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($234) { __label__ = 44; break; } else { __label__ = 55; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + var $236=$XP; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $237=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $238=(($237+24)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($238)>>2)]=$236; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $239=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $240=(($239+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $241=(($240)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $242=HEAP32[(($241)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $C0=$242; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $243=(($242)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($243) { __label__ = 45; break; } else { __label__ = 49; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + var $245=$C0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $246=$245; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $247=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($247+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $249=HEAP32[(($248)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $250=(($246)>>>0) >= (($249)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $251=(($250)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $252=(($251)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $253=(($252)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($253) { __label__ = 46; break; } else { __label__ = 47; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $255=$C0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $256=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $257=(($256+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $258=(($257)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($258)>>2)]=$255; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $259=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $260=$C0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $261=(($260+24)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($261)>>2)]=$259; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 48; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + __label__ = 49; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $265=$tp; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $266=(($265+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $267=(($266+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $268=HEAP32[(($267)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + $C1=$268; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $269=(($268)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($269) { __label__ = 50; break; } else { __label__ = 54; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + var $271=$C1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $272=$271; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $273=$1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $274=(($273+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $275=HEAP32[(($274)>>2)]; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($272)>>>0) >= (($275)>>>0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $277=(($276)&1); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $278=(($277)==(1)); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $279=(($278)|0)!=0; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + if ($279) { __label__ = 51; break; } else { __label__ = 52; break; } //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + var $281=$C1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $282=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $283=(($282+16)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $284=(($283+4)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($284)>>2)]=$281; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $285=$R; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $286=$C1; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + var $287=(($286+24)|0); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($287)>>2)]=$285; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 53; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 52: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 53: + __label__ = 54; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + __label__ = 56; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 55: + _abort(); //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + __label__ = 57; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + __label__ = 58; break; //@line 4100 "/root/emscripten/system/lib/dlmalloc.c" + case 58: + __label__ = 59; break; + case 59: + var $296=$psize; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $297=$296 >>> 8; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $X=$297; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $298=$X; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $299=(($298)|0)==0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($299) { __label__ = 60; break; } else { __label__ = 61; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + $I=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 65; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + var $302=$X; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $303=(($302)>>>0) > 65535; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($303) { __label__ = 62; break; } else { __label__ = 63; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + $I=31; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 64; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 63: + var $306=$X; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$306; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $307=$Y; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $308=((($307)-(256))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $309=$308 >>> 16; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $310=$309 & 8; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $N=$310; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $311=$N; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $312=$Y; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $313=$312 << $311; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$313; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $314=((($313)-(4096))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $315=$314 >>> 16; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $316=$315 & 4; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $K=$316; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $317=$K; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $318=$N; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $319=((($318)+($317))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $N=$319; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $320=$K; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $321=$Y; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $322=$321 << $320; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$322; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $323=((($322)-(16384))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $324=$323 >>> 16; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $325=$324 & 2; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $K=$325; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $326=$N; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $327=((($326)+($325))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $N=$327; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $328=$N; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $329=(((14)-($328))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $330=$K; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $331=$Y; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $332=$331 << $330; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$332; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $333=$332 >>> 15; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $334=((($329)+($333))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $K=$334; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $335=$K; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $336=$335 << 1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $337=$psize; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $338=$K; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $339=((($338)+(7))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $340=$337 >>> (($339)>>>0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $341=$340 & 1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $342=((($336)+($341))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $I=$342; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 64; break; + case 64: + __label__ = 65; break; + case 65: + var $345=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $346=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $347=(($346+304)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $348=(($347+($345<<2))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $H1=$348; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $349=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $350=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $351=(($350+28)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($351)>>2)]=$349; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $352=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $353=(($352+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $354=(($353+4)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($354)>>2)]=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $355=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $356=(($355+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $357=(($356)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($357)>>2)]=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $358=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $359=(($358+4)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $360=HEAP32[(($359)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $361=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $362=1 << $361; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $363=$360 & $362; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $364=(($363)|0)!=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($364) { __label__ = 67; break; } else { __label__ = 66; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 66: + var $366=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $367=1 << $366; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $369=(($368+4)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $370=HEAP32[(($369)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $371=$370 | $367; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($369)>>2)]=$371; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $372=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $373=$H1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($373)>>2)]=$372; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $374=$H1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $375=$374; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $376=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $377=(($376+24)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($377)>>2)]=$375; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $378=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $379=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $380=(($379+12)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($380)>>2)]=$378; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $381=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $382=(($381+8)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($382)>>2)]=$378; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 85; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 67: + var $384=$H1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $385=HEAP32[(($384)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $T=$385; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $386=$psize; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $387=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $388=(($387)|0)==31; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($388) { __label__ = 68; break; } else { __label__ = 69; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 68: + var $397 = 0;__label__ = 70; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + var $391=$I; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $392=$391 >>> 1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $393=((($392)+(8))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $394=((($393)-(2))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $395=(((31)-($394))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $397 = $395;__label__ = 70; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 70: + var $397; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $398=$386 << $397; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$398; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 71; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 71: + var $400=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $401=(($400+4)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $402=HEAP32[(($401)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $403=$402 & -8; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $404=$psize; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $405=(($403)|0)!=(($404)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($405) { __label__ = 72; break; } else { __label__ = 78; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 72: + var $407=$K2; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $408=$407 >>> 31; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $409=$408 & 1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $410=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $411=(($410+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $412=(($411+($409<<2))|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $C=$412; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $413=$K2; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $414=$413 << 1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$414; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $415=$C; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $416=HEAP32[(($415)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $417=(($416)|0)!=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($417) { __label__ = 73; break; } else { __label__ = 74; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 73: + var $419=$C; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $420=HEAP32[(($419)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $T=$420; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 77; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 74: + var $422=$C; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $423=$422; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $424=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $425=(($424+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $426=HEAP32[(($425)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $427=(($423)>>>0) >= (($426)>>>0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $428=(($427)&1); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $429=(($428)==(1)); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $430=(($429)|0)!=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($430) { __label__ = 75; break; } else { __label__ = 76; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 75: + var $432=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $433=$C; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($433)>>2)]=$432; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $434=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $435=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $436=(($435+24)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($436)>>2)]=$434; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $437=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $438=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $439=(($438+12)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($439)>>2)]=$437; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $440=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $441=(($440+8)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($441)>>2)]=$437; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 84; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 76: + _abort(); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 77: + __label__ = 83; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 78: + var $445=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $446=(($445+8)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $447=HEAP32[(($446)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + $F3=$447; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $448=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $449=$448; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $450=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $451=(($450+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $452=HEAP32[(($451)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $453=(($449)>>>0) >= (($452)>>>0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + if ($453) { __label__ = 79; break; } else { var $462 = 0;__label__ = 80; break; } //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 79: + var $455=$F3; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $456=$455; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $457=$1; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $458=(($457+16)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $459=HEAP32[(($458)>>2)]; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $460=(($456)>>>0) >= (($459)>>>0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $462 = $460;__label__ = 80; break; + case 80: + var $462; + var $463=(($462)&1); + var $464=(($463)==(1)); + var $465=(($464)|0)!=0; + if ($465) { __label__ = 81; break; } else { __label__ = 82; break; } + case 81: + var $467=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $468=$F3; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $469=(($468+12)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($469)>>2)]=$467; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $470=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $471=(($470+8)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($471)>>2)]=$467; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $472=$F3; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $473=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $474=(($473+8)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($474)>>2)]=$472; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $475=$T; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $476=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $477=(($476+12)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($477)>>2)]=$475; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $478=$tp; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + var $479=(($478+24)|0); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($479)>>2)]=0; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 84; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 82: + _abort(); //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 83: + __label__ = 71; break; //@line 4110 "/root/emscripten/system/lib/dlmalloc.c" + case 84: + __label__ = 85; break; + case 85: + __label__ = 86; break; //@line 4112 "/root/emscripten/system/lib/dlmalloc.c" + case 86: + __label__ = 87; break; //@line 4113 "/root/emscripten/system/lib/dlmalloc.c" + case 87: + var $486=$sp; //@line 4116 "/root/emscripten/system/lib/dlmalloc.c" + $pred=$486; //@line 4116 "/root/emscripten/system/lib/dlmalloc.c" + var $487=$next; //@line 4117 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$487; //@line 4117 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 4118 "/root/emscripten/system/lib/dlmalloc.c" + case 88: + var $489=$nsegs; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + var $490=(($489)>>>0) > 4294967295; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + if ($490) { __label__ = 89; break; } else { __label__ = 90; break; } //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + case 89: + var $492=$nsegs; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + var $495 = $492;__label__ = 91; break; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + case 90: + var $495 = -1;__label__ = 91; break; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + case 91: + var $495; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + var $496=$1; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + var $497=(($496+32)|0); //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($497)>>2)]=$495; //@line 4120 "/root/emscripten/system/lib/dlmalloc.c" + var $498=$released; //@line 4122 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $498; //@line 4122 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_release_unused_segments["X"]=1; + +function _init_mparams() { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $magic; + var $psize; + var $gsize; + var $1=HEAP32[((((_mparams)|0))>>2)]; //@line 2965 "/root/emscripten/system/lib/dlmalloc.c" + var $2=(($1)|0)==0; //@line 2965 "/root/emscripten/system/lib/dlmalloc.c" + if ($2) { __label__ = 3; break; } else { __label__ = 7; break; } //@line 2965 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $4=_sysconf(8); //@line 2971 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$4; //@line 2971 "/root/emscripten/system/lib/dlmalloc.c" + var $5=$psize; //@line 2972 "/root/emscripten/system/lib/dlmalloc.c" + $gsize=$5; //@line 2972 "/root/emscripten/system/lib/dlmalloc.c" + var $6=$gsize; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $7=$gsize; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $8=((($7)-(1))|0); //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $9=$6 & $8; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $10=(($9)|0)!=0; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + if ($10) { __label__ = 5; break; } else { __label__ = 4; break; } //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $12=$psize; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $13=$psize; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $14=((($13)-(1))|0); //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$12 & $14; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + var $16=(($15)|0)!=0; //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + if ($16) { __label__ = 5; break; } else { __label__ = 6; break; } //@line 2989 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + _abort(); //@line 2997 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 2997 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $19=$gsize; //@line 2999 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams+8)|0))>>2)]=$19; //@line 2999 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$psize; //@line 3000 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams+4)|0))>>2)]=$20; //@line 3000 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams+12)|0))>>2)]=-1; //@line 3001 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams+16)|0))>>2)]=2097152; //@line 3002 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams+20)|0))>>2)]=0; //@line 3004 "/root/emscripten/system/lib/dlmalloc.c" + var $21=HEAP32[((((_mparams+20)|0))>>2)]; //@line 3011 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((__gm_+440)|0))>>2)]=$21; //@line 3011 "/root/emscripten/system/lib/dlmalloc.c" + var $22=_time(0); //@line 3030 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$22 ^ 1431655765; //@line 3030 "/root/emscripten/system/lib/dlmalloc.c" + $magic=$23; //@line 3030 "/root/emscripten/system/lib/dlmalloc.c" + var $24=$magic; //@line 3032 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$24 | 8; //@line 3032 "/root/emscripten/system/lib/dlmalloc.c" + $magic=$25; //@line 3032 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$magic; //@line 3033 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$26 & -8; //@line 3033 "/root/emscripten/system/lib/dlmalloc.c" + $magic=$27; //@line 3033 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$magic; //@line 3034 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[((((_mparams)|0))>>2)]=$28; //@line 3034 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 7; break; //@line 3036 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + ; + return 1; //@line 3039 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} + + +function _init_top($m, $p, $psize) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $offset; + $1=$m; + $2=$p; + $3=$psize; + var $4=$2; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $5=$4; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $6=(($5+8)|0); //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $7=$6; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$7 & 7; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(($8)|0)==0; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + if ($9) { __label__ = 3; break; } else { __label__ = 4; break; } //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $20 = 0;__label__ = 5; break; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $12=$2; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $13=$12; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $14=(($13+8)|0); //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$14; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$15 & 7; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $17=(((8)-($16))|0); //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $18=$17 & 7; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $20 = $18;__label__ = 5; break; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $20; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + $offset=$20; //@line 3736 "/root/emscripten/system/lib/dlmalloc.c" + var $21=$2; //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + var $22=$21; //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$offset; //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + var $24=(($22+$23)|0); //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$24; //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + $2=$25; //@line 3737 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$offset; //@line 3738 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$3; //@line 3738 "/root/emscripten/system/lib/dlmalloc.c" + var $28=((($27)-($26))|0); //@line 3738 "/root/emscripten/system/lib/dlmalloc.c" + $3=$28; //@line 3738 "/root/emscripten/system/lib/dlmalloc.c" + var $29=$2; //@line 3740 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$1; //@line 3740 "/root/emscripten/system/lib/dlmalloc.c" + var $31=(($30+24)|0); //@line 3740 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($31)>>2)]=$29; //@line 3740 "/root/emscripten/system/lib/dlmalloc.c" + var $32=$3; //@line 3741 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$1; //@line 3741 "/root/emscripten/system/lib/dlmalloc.c" + var $34=(($33+12)|0); //@line 3741 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($34)>>2)]=$32; //@line 3741 "/root/emscripten/system/lib/dlmalloc.c" + var $35=$3; //@line 3742 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$35 | 1; //@line 3742 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$2; //@line 3742 "/root/emscripten/system/lib/dlmalloc.c" + var $38=(($37+4)|0); //@line 3742 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($38)>>2)]=$36; //@line 3742 "/root/emscripten/system/lib/dlmalloc.c" + var $39=$2; //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$39; //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$3; //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $42=(($40+$41)|0); //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$42; //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $44=(($43+4)|0); //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($44)>>2)]=40; //@line 3744 "/root/emscripten/system/lib/dlmalloc.c" + var $45=HEAP32[((((_mparams+16)|0))>>2)]; //@line 3745 "/root/emscripten/system/lib/dlmalloc.c" + var $46=$1; //@line 3745 "/root/emscripten/system/lib/dlmalloc.c" + var $47=(($46+28)|0); //@line 3745 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($47)>>2)]=$45; //@line 3745 "/root/emscripten/system/lib/dlmalloc.c" + ; + return; //@line 3746 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_init_top["X"]=1; + +function _mmap_alloc($m, $nb) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $mmsize; + var $mm; + var $offset; + var $psize; + var $p; + $2=$m; + $3=$nb; + var $4=$3; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $5=((($4)+(24))|0); //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $6=((($5)+(7))|0); //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $7=HEAP32[((((_mparams+4)|0))>>2)]; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $8=((($7)-(1))|0); //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $9=((($6)+($8))|0); //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $10=HEAP32[((((_mparams+4)|0))>>2)]; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $11=((($10)-(1))|0); //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $12=$11 ^ -1; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $13=$9 & $12; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + $mmsize=$13; //@line 3672 "/root/emscripten/system/lib/dlmalloc.c" + var $14=$mmsize; //@line 3673 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$3; //@line 3673 "/root/emscripten/system/lib/dlmalloc.c" + var $16=(($14)>>>0) > (($15)>>>0); //@line 3673 "/root/emscripten/system/lib/dlmalloc.c" + if ($16) { __label__ = 3; break; } else { __label__ = 14; break; } //@line 3673 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + $mm=-1; //@line 3674 "/root/emscripten/system/lib/dlmalloc.c" + var $18=$mm; //@line 3675 "/root/emscripten/system/lib/dlmalloc.c" + var $19=(($18)|0)!=-1; //@line 3675 "/root/emscripten/system/lib/dlmalloc.c" + if ($19) { __label__ = 4; break; } else { __label__ = 13; break; } //@line 3675 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $21=$mm; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $22=(($21+8)|0); //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$22; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $24=$23 & 7; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $25=(($24)|0)==0; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + if ($25) { __label__ = 5; break; } else { __label__ = 6; break; } //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $35 = 0;__label__ = 7; break; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $28=$mm; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $29=(($28+8)|0); //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $30=$29; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $31=$30 & 7; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $32=(((8)-($31))|0); //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$32 & 7; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $35 = $33;__label__ = 7; break; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $35; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + $offset=$35; //@line 3676 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$mmsize; //@line 3677 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$offset; //@line 3677 "/root/emscripten/system/lib/dlmalloc.c" + var $38=((($36)-($37))|0); //@line 3677 "/root/emscripten/system/lib/dlmalloc.c" + var $39=((($38)-(16))|0); //@line 3677 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$39; //@line 3677 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$mm; //@line 3678 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$offset; //@line 3678 "/root/emscripten/system/lib/dlmalloc.c" + var $42=(($40+$41)|0); //@line 3678 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$42; //@line 3678 "/root/emscripten/system/lib/dlmalloc.c" + $p=$43; //@line 3678 "/root/emscripten/system/lib/dlmalloc.c" + var $44=$offset; //@line 3679 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$p; //@line 3679 "/root/emscripten/system/lib/dlmalloc.c" + var $46=(($45)|0); //@line 3679 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($46)>>2)]=$44; //@line 3679 "/root/emscripten/system/lib/dlmalloc.c" + var $47=$psize; //@line 3680 "/root/emscripten/system/lib/dlmalloc.c" + var $48=$p; //@line 3680 "/root/emscripten/system/lib/dlmalloc.c" + var $49=(($48+4)|0); //@line 3680 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($49)>>2)]=$47; //@line 3680 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$p; //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $51=$50; //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $52=$psize; //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $53=(($51+$52)|0); //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $54=$53; //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $55=(($54+4)|0); //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($55)>>2)]=7; //@line 3682 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$p; //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $57=$56; //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $58=$psize; //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $59=((($58)+(4))|0); //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $60=(($57+$59)|0); //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $61=$60; //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $62=(($61+4)|0); //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($62)>>2)]=0; //@line 3683 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$2; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $64=(($63+16)|0); //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $65=HEAP32[(($64)>>2)]; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $66=(($65)|0)==0; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + if ($66) { __label__ = 9; break; } else { __label__ = 8; break; } //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $68=$mm; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $69=$2; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $70=(($69+16)|0); //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $71=HEAP32[(($70)>>2)]; //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + var $72=(($68)>>>0) < (($71)>>>0); //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + if ($72) { __label__ = 9; break; } else { __label__ = 10; break; } //@line 3685 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $74=$mm; //@line 3686 "/root/emscripten/system/lib/dlmalloc.c" + var $75=$2; //@line 3686 "/root/emscripten/system/lib/dlmalloc.c" + var $76=(($75+16)|0); //@line 3686 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($76)>>2)]=$74; //@line 3686 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 10; break; //@line 3686 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $78=$mmsize; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $79=$2; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $80=(($79+432)|0); //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $81=HEAP32[(($80)>>2)]; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $82=((($81)+($78))|0); //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($80)>>2)]=$82; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $83=$2; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $84=(($83+436)|0); //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $85=HEAP32[(($84)>>2)]; //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + var $86=(($82)>>>0) > (($85)>>>0); //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + if ($86) { __label__ = 11; break; } else { __label__ = 12; break; } //@line 3687 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $88=$2; //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + var $89=(($88+432)|0); //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + var $90=HEAP32[(($89)>>2)]; //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + var $91=$2; //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + var $92=(($91+436)|0); //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($92)>>2)]=$90; //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 12; break; //@line 3688 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $94=$p; //@line 3691 "/root/emscripten/system/lib/dlmalloc.c" + var $95=$94; //@line 3691 "/root/emscripten/system/lib/dlmalloc.c" + var $96=(($95+8)|0); //@line 3691 "/root/emscripten/system/lib/dlmalloc.c" + $1=$96; //@line 3691 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 15; break; //@line 3691 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + __label__ = 14; break; //@line 3693 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + $1=0; //@line 3694 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 15; break; //@line 3694 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $100=$1; //@line 3695 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $100; //@line 3695 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_mmap_alloc["X"]=1; + +function _init_bins($m) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $i; + var $bin; + $1=$m; + $i=0; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $3=$i; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + var $4=(($3)>>>0) < 32; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + if ($4) { __label__ = 4; break; } else { __label__ = 6; break; } //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $6=$i; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $7=$6 << 1; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$1; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $9=(($8+40)|0); //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $10=(($9+($7<<2))|0); //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $11=$10; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $12=$11; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + $bin=$12; //@line 3753 "/root/emscripten/system/lib/dlmalloc.c" + var $13=$bin; //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + var $14=$bin; //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + var $15=(($14+12)|0); //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($15)>>2)]=$13; //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$bin; //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + var $17=(($16+8)|0); //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($17)>>2)]=$13; //@line 3754 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 5; break; //@line 3755 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $19=$i; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + var $20=((($19)+(1))|0); //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + $i=$20; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 3; break; //@line 3752 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + ; + return; //@line 3756 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} + + +function _prepend_alloc($m, $newbase, $oldbase, $nb) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $p; + var $oldfirst; + var $psize; + var $q; + var $qsize; + var $tsize; + var $dsize; + var $nsize; + var $F; + var $B; + var $I; + var $TP; + var $XP; + var $R; + var $F1; + var $RP; + var $CP; + var $H; + var $C0; + var $C1; + var $I2; + var $B3; + var $F4; + var $TP5; + var $H6; + var $I7; + var $X; + var $Y; + var $N; + var $K; + var $T; + var $K8; + var $C; + var $F9; + $1=$m; + $2=$newbase; + $3=$oldbase; + $4=$nb; + var $5=$2; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $6=$2; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $7=(($6+8)|0); //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$7; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $9=$8 & 7; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $10=(($9)|0)==0; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + if ($10) { __label__ = 3; break; } else { __label__ = 4; break; } //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $20 = 0;__label__ = 5; break; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $13=$2; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $14=(($13+8)|0); //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$14; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $16=$15 & 7; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $17=(((8)-($16))|0); //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $18=$17 & 7; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $20 = $18;__label__ = 5; break; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $20; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $21=(($5+$20)|0); //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $22=$21; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + $p=$22; //@line 3780 "/root/emscripten/system/lib/dlmalloc.c" + var $23=$3; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $24=$3; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $25=(($24+8)|0); //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $26=$25; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$26 & 7; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $28=(($27)|0)==0; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + if ($28) { __label__ = 6; break; } else { __label__ = 7; break; } //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $38 = 0;__label__ = 8; break; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $31=$3; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $32=(($31+8)|0); //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $33=$32; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $34=$33 & 7; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $35=(((8)-($34))|0); //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $36=$35 & 7; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $38 = $36;__label__ = 8; break; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $38; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $39=(($23+$38)|0); //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$39; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + $oldfirst=$40; //@line 3781 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$oldfirst; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $42=$41; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$p; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $44=$43; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $45=$42; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $46=$44; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $47=((($45)-($46))|0); //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$47; //@line 3782 "/root/emscripten/system/lib/dlmalloc.c" + var $48=$p; //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + var $49=$48; //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + var $50=$4; //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + var $51=(($49+$50)|0); //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + var $52=$51; //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + $q=$52; //@line 3783 "/root/emscripten/system/lib/dlmalloc.c" + var $53=$psize; //@line 3784 "/root/emscripten/system/lib/dlmalloc.c" + var $54=$4; //@line 3784 "/root/emscripten/system/lib/dlmalloc.c" + var $55=((($53)-($54))|0); //@line 3784 "/root/emscripten/system/lib/dlmalloc.c" + $qsize=$55; //@line 3784 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$4; //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + var $57=$56 | 1; //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + var $58=$57 | 2; //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + var $59=$p; //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + var $60=(($59+4)|0); //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($60)>>2)]=$58; //@line 3785 "/root/emscripten/system/lib/dlmalloc.c" + var $61=$oldfirst; //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + var $62=$1; //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + var $63=(($62+24)|0); //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + var $64=HEAP32[(($63)>>2)]; //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + var $65=(($61)|0)==(($64)|0); //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + if ($65) { __label__ = 9; break; } else { __label__ = 10; break; } //@line 3792 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $67=$qsize; //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + var $68=$1; //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + var $69=(($68+12)|0); //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + var $70=HEAP32[(($69)>>2)]; //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + var $71=((($70)+($67))|0); //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($69)>>2)]=$71; //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + $tsize=$71; //@line 3793 "/root/emscripten/system/lib/dlmalloc.c" + var $72=$q; //@line 3794 "/root/emscripten/system/lib/dlmalloc.c" + var $73=$1; //@line 3794 "/root/emscripten/system/lib/dlmalloc.c" + var $74=(($73+24)|0); //@line 3794 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($74)>>2)]=$72; //@line 3794 "/root/emscripten/system/lib/dlmalloc.c" + var $75=$tsize; //@line 3795 "/root/emscripten/system/lib/dlmalloc.c" + var $76=$75 | 1; //@line 3795 "/root/emscripten/system/lib/dlmalloc.c" + var $77=$q; //@line 3795 "/root/emscripten/system/lib/dlmalloc.c" + var $78=(($77+4)|0); //@line 3795 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($78)>>2)]=$76; //@line 3795 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 110; break; //@line 3797 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $80=$oldfirst; //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + var $81=$1; //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + var $82=(($81+20)|0); //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + var $83=HEAP32[(($82)>>2)]; //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + var $84=(($80)|0)==(($83)|0); //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + if ($84) { __label__ = 11; break; } else { __label__ = 12; break; } //@line 3798 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + var $86=$qsize; //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + var $87=$1; //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + var $88=(($87+8)|0); //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + var $89=HEAP32[(($88)>>2)]; //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + var $90=((($89)+($86))|0); //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($88)>>2)]=$90; //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + $dsize=$90; //@line 3799 "/root/emscripten/system/lib/dlmalloc.c" + var $91=$q; //@line 3800 "/root/emscripten/system/lib/dlmalloc.c" + var $92=$1; //@line 3800 "/root/emscripten/system/lib/dlmalloc.c" + var $93=(($92+20)|0); //@line 3800 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($93)>>2)]=$91; //@line 3800 "/root/emscripten/system/lib/dlmalloc.c" + var $94=$dsize; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $95=$94 | 1; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $96=$q; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $97=(($96+4)|0); //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($97)>>2)]=$95; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $98=$dsize; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $99=$q; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $100=$99; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$dsize; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $102=(($100+$101)|0); //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $103=$102; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + var $104=(($103)|0); //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($104)>>2)]=$98; //@line 3801 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 109; break; //@line 3802 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + var $106=$oldfirst; //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + var $107=(($106+4)|0); //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + var $108=HEAP32[(($107)>>2)]; //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + var $109=$108 & 3; //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + var $110=(($109)|0)!=1; //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + if ($110) { __label__ = 73; break; } else { __label__ = 13; break; } //@line 3804 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $112=$oldfirst; //@line 3805 "/root/emscripten/system/lib/dlmalloc.c" + var $113=(($112+4)|0); //@line 3805 "/root/emscripten/system/lib/dlmalloc.c" + var $114=HEAP32[(($113)>>2)]; //@line 3805 "/root/emscripten/system/lib/dlmalloc.c" + var $115=$114 & -8; //@line 3805 "/root/emscripten/system/lib/dlmalloc.c" + $nsize=$115; //@line 3805 "/root/emscripten/system/lib/dlmalloc.c" + var $116=$nsize; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $117=$116 >>> 3; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $118=(($117)>>>0) < 32; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($118) { __label__ = 14; break; } else { __label__ = 26; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $120=$oldfirst; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $121=(($120+8)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $122=HEAP32[(($121)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $F=$122; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $123=$oldfirst; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $124=(($123+12)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $125=HEAP32[(($124)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $B=$125; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $126=$nsize; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $127=$126 >>> 3; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $I=$127; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $128=$F; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $129=$B; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $130=(($128)|0)==(($129)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($130) { __label__ = 15; break; } else { __label__ = 16; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $132=$I; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $133=1 << $132; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $134=$133 ^ -1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $135=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $136=(($135)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $137=HEAP32[(($136)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $138=$137 & $134; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($136)>>2)]=$138; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 25; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + var $140=$F; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $141=$I; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $142=$141 << 1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $143=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $144=(($143+40)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $145=(($144+($142<<2))|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $146=$145; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $147=$146; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $148=(($140)|0)==(($147)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($148) { __label__ = 18; break; } else { __label__ = 17; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $150=$F; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $151=$150; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $152=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $153=(($152+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $154=HEAP32[(($153)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $155=(($151)>>>0) >= (($154)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($155) { __label__ = 18; break; } else { var $176 = 0;__label__ = 21; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $157=$B; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $158=$I; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $159=$158 << 1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $160=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $161=(($160+40)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $162=(($161+($159<<2))|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $163=$162; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $164=$163; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $165=(($157)|0)==(($164)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($165) { var $174 = 1;__label__ = 20; break; } else { __label__ = 19; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + var $167=$B; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $168=$167; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $169=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $170=(($169+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $171=HEAP32[(($170)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $172=(($168)>>>0) >= (($171)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $174 = $172;__label__ = 20; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + var $174; + var $176 = $174;__label__ = 21; break; + case 21: + var $176; + var $177=(($176)&1); + var $178=(($177)==(1)); + var $179=(($178)|0)!=0; + if ($179) { __label__ = 22; break; } else { __label__ = 23; break; } + case 22: + var $181=$B; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $182=$F; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $183=(($182+12)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($183)>>2)]=$181; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $184=$F; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $185=$B; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $186=(($185+8)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($186)>>2)]=$184; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 24; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + __label__ = 25; break; + case 25: + __label__ = 72; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $191=$oldfirst; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $192=$191; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $TP=$192; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $193=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $194=(($193+24)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $195=HEAP32[(($194)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $XP=$195; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $196=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $197=(($196+12)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $198=HEAP32[(($197)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $199=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $200=(($198)|0)!=(($199)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($200) { __label__ = 27; break; } else { __label__ = 31; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 27: + var $202=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $203=(($202+8)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $204=HEAP32[(($203)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $F1=$204; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $205=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $206=(($205+12)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $207=HEAP32[(($206)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $R=$207; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $208=$F1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $209=$208; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $210=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $211=(($210+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $212=HEAP32[(($211)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $213=(($209)>>>0) >= (($212)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $214=(($213)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $215=(($214)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $216=(($215)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($216) { __label__ = 28; break; } else { __label__ = 29; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 28: + var $218=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $219=$F1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $220=(($219+12)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($220)>>2)]=$218; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $221=$F1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $222=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $223=(($222+8)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($223)>>2)]=$221; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 30; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + __label__ = 43; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $227=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $228=(($227+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $229=(($228+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$229; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $230=HEAP32[(($229)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $R=$230; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $231=(($230)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($231) { __label__ = 33; break; } else { __label__ = 32; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $233=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $234=(($233+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $235=(($234)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$235; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $236=HEAP32[(($235)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $R=$236; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $237=(($236)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($237) { __label__ = 33; break; } else { __label__ = 42; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + __label__ = 34; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $240=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $241=(($240+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $242=(($241+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$242; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $243=HEAP32[(($242)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $244=(($243)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($244) { var $252 = 1;__label__ = 36; break; } else { __label__ = 35; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $246=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $247=(($246+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $248=(($247)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $CP=$248; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $249=HEAP32[(($248)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $250=(($249)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $252 = $250;__label__ = 36; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $252; + if ($252) { __label__ = 37; break; } else { __label__ = 38; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $254=$CP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $RP=$254; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $255=HEAP32[(($254)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $R=$255; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 34; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $257=$RP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $258=$257; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $259=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $260=(($259+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $261=HEAP32[(($260)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $262=(($258)>>>0) >= (($261)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $263=(($262)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $264=(($263)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $265=(($264)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($265) { __label__ = 39; break; } else { __label__ = 40; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + var $267=$RP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($267)>>2)]=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 41; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 41: + __label__ = 42; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + __label__ = 43; break; + case 43: + var $272=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $273=(($272)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($273) { __label__ = 44; break; } else { __label__ = 71; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 44: + var $275=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($275+28)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $277=HEAP32[(($276)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $278=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $279=(($278+304)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $280=(($279+($277<<2))|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $H=$280; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $281=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $282=$H; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $283=HEAP32[(($282)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $284=(($281)|0)==(($283)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($284) { __label__ = 45; break; } else { __label__ = 48; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + var $286=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $287=$H; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($287)>>2)]=$286; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $288=(($286)|0)==0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($288) { __label__ = 46; break; } else { __label__ = 47; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + var $290=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $291=(($290+28)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $292=HEAP32[(($291)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $293=1 << $292; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $294=$293 ^ -1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $295=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $296=(($295+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $297=HEAP32[(($296)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $298=$297 & $294; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($296)>>2)]=$298; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 47; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + __label__ = 55; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 48: + var $301=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $302=$301; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $303=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $304=(($303+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $305=HEAP32[(($304)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $306=(($302)>>>0) >= (($305)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $307=(($306)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $308=(($307)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $309=(($308)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($309) { __label__ = 49; break; } else { __label__ = 53; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 49: + var $311=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $312=(($311+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $313=(($312)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $314=HEAP32[(($313)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $315=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $316=(($314)|0)==(($315)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($316) { __label__ = 50; break; } else { __label__ = 51; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + var $318=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $319=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $320=(($319+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $321=(($320)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($321)>>2)]=$318; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 52; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 51: + var $323=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $324=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $325=(($324+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $326=(($325+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($326)>>2)]=$323; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 52; break; + case 52: + __label__ = 54; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 53: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 54: + __label__ = 55; break; + case 55: + var $331=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $332=(($331)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($332) { __label__ = 56; break; } else { __label__ = 70; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 56: + var $334=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $335=$334; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $336=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $337=(($336+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $338=HEAP32[(($337)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $339=(($335)>>>0) >= (($338)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $340=(($339)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $341=(($340)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $342=(($341)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($342) { __label__ = 57; break; } else { __label__ = 68; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 57: + var $344=$XP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $345=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $346=(($345+24)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($346)>>2)]=$344; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $347=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $348=(($347+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $349=(($348)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $350=HEAP32[(($349)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $C0=$350; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $351=(($350)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($351) { __label__ = 58; break; } else { __label__ = 62; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 58: + var $353=$C0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $354=$353; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $355=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $356=(($355+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $357=HEAP32[(($356)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $358=(($354)>>>0) >= (($357)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $359=(($358)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $360=(($359)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $361=(($360)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($361) { __label__ = 59; break; } else { __label__ = 60; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 59: + var $363=$C0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $364=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $365=(($364+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $366=(($365)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($366)>>2)]=$363; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $367=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$C0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $369=(($368+24)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($369)>>2)]=$367; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 61; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 60: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 61: + __label__ = 62; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 62: + var $373=$TP; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $374=(($373+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $375=(($374+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $376=HEAP32[(($375)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + $C1=$376; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $377=(($376)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($377) { __label__ = 63; break; } else { __label__ = 67; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 63: + var $379=$C1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $380=$379; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $381=$1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $382=(($381+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $383=HEAP32[(($382)>>2)]; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $384=(($380)>>>0) >= (($383)>>>0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $385=(($384)&1); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $386=(($385)==(1)); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $387=(($386)|0)!=0; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + if ($387) { __label__ = 64; break; } else { __label__ = 65; break; } //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 64: + var $389=$C1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $390=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $391=(($390+16)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $392=(($391+4)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($392)>>2)]=$389; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $393=$R; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $394=$C1; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + var $395=(($394+24)|0); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($395)>>2)]=$393; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 66; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 65: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 66: + __label__ = 67; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 67: + __label__ = 69; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 68: + _abort(); //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 69: + __label__ = 70; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 70: + __label__ = 71; break; //@line 3806 "/root/emscripten/system/lib/dlmalloc.c" + case 71: + __label__ = 72; break; + case 72: + var $404=$oldfirst; //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + var $405=$404; //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + var $406=$nsize; //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + var $407=(($405+$406)|0); //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + var $408=$407; //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + $oldfirst=$408; //@line 3807 "/root/emscripten/system/lib/dlmalloc.c" + var $409=$nsize; //@line 3808 "/root/emscripten/system/lib/dlmalloc.c" + var $410=$qsize; //@line 3808 "/root/emscripten/system/lib/dlmalloc.c" + var $411=((($410)+($409))|0); //@line 3808 "/root/emscripten/system/lib/dlmalloc.c" + $qsize=$411; //@line 3808 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 73; break; //@line 3809 "/root/emscripten/system/lib/dlmalloc.c" + case 73: + var $413=$oldfirst; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $414=(($413+4)|0); //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $415=HEAP32[(($414)>>2)]; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $416=$415 & -2; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($414)>>2)]=$416; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $417=$qsize; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $418=$417 | 1; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $419=$q; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $420=(($419+4)|0); //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($420)>>2)]=$418; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $421=$qsize; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $422=$q; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $423=$422; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $424=$qsize; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $425=(($423+$424)|0); //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $426=$425; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $427=(($426)|0); //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($427)>>2)]=$421; //@line 3810 "/root/emscripten/system/lib/dlmalloc.c" + var $428=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $429=$428 >>> 3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $430=(($429)>>>0) < 32; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($430) { __label__ = 74; break; } else { __label__ = 81; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 74: + var $432=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $433=$432 >>> 3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $I2=$433; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $434=$I2; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $435=$434 << 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $436=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $437=(($436+40)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $438=(($437+($435<<2))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $439=$438; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $440=$439; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $B3=$440; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $441=$B3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $F4=$441; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $442=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $443=(($442)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $444=HEAP32[(($443)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $445=$I2; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $446=1 << $445; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $447=$444 & $446; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $448=(($447)|0)!=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($448) { __label__ = 76; break; } else { __label__ = 75; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 75: + var $450=$I2; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $451=1 << $450; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $452=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $453=(($452)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $454=HEAP32[(($453)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $455=$454 | $451; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($453)>>2)]=$455; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 80; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 76: + var $457=$B3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $458=(($457+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $459=HEAP32[(($458)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $460=$459; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $461=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $462=(($461+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $463=HEAP32[(($462)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $464=(($460)>>>0) >= (($463)>>>0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $465=(($464)&1); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $466=(($465)==(1)); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $467=(($466)|0)!=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($467) { __label__ = 77; break; } else { __label__ = 78; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 77: + var $469=$B3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $470=(($469+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $471=HEAP32[(($470)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $F4=$471; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 79; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 78: + _abort(); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 79: + __label__ = 80; break; + case 80: + var $475=$q; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $476=$B3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $477=(($476+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($477)>>2)]=$475; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $478=$q; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $479=$F4; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $480=(($479+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($480)>>2)]=$478; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $481=$F4; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $482=$q; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $483=(($482+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($483)>>2)]=$481; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $484=$B3; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $485=$q; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $486=(($485+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($486)>>2)]=$484; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 108; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 81: + var $488=$q; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $489=$488; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $TP5=$489; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $490=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $491=$490 >>> 8; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $X=$491; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $492=$X; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $493=(($492)|0)==0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($493) { __label__ = 82; break; } else { __label__ = 83; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 82: + $I7=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 87; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 83: + var $496=$X; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $497=(($496)>>>0) > 65535; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($497) { __label__ = 84; break; } else { __label__ = 85; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 84: + $I7=31; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 86; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 85: + var $500=$X; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$500; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $501=$Y; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $502=((($501)-(256))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $503=$502 >>> 16; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $504=$503 & 8; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $N=$504; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $505=$N; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $506=$Y; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $507=$506 << $505; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$507; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $508=((($507)-(4096))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $509=$508 >>> 16; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $510=$509 & 4; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $K=$510; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $511=$K; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $512=$N; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $513=((($512)+($511))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $N=$513; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $514=$K; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $515=$Y; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $516=$515 << $514; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$516; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $517=((($516)-(16384))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $518=$517 >>> 16; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $519=$518 & 2; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $K=$519; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $520=$N; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $521=((($520)+($519))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $N=$521; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $522=$N; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $523=(((14)-($522))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $524=$K; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $525=$Y; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $526=$525 << $524; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$526; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $527=$526 >>> 15; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $528=((($523)+($527))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $K=$528; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $529=$K; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $530=$529 << 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $531=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $532=$K; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $533=((($532)+(7))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $534=$531 >>> (($533)>>>0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $535=$534 & 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $536=((($530)+($535))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $I7=$536; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 86; break; + case 86: + __label__ = 87; break; + case 87: + var $539=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $540=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $541=(($540+304)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $542=(($541+($539<<2))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $H6=$542; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $543=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $544=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $545=(($544+28)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($545)>>2)]=$543; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $546=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $547=(($546+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $548=(($547+4)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($548)>>2)]=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $549=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $550=(($549+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $551=(($550)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($551)>>2)]=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $552=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $553=(($552+4)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $554=HEAP32[(($553)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $555=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $556=1 << $555; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $557=$554 & $556; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $558=(($557)|0)!=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($558) { __label__ = 89; break; } else { __label__ = 88; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 88: + var $560=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $561=1 << $560; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $562=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $563=(($562+4)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $564=HEAP32[(($563)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $565=$564 | $561; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($563)>>2)]=$565; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $566=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $567=$H6; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($567)>>2)]=$566; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $568=$H6; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $569=$568; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $570=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $571=(($570+24)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($571)>>2)]=$569; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $572=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $573=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $574=(($573+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($574)>>2)]=$572; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $575=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $576=(($575+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($576)>>2)]=$572; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 107; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 89: + var $578=$H6; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $579=HEAP32[(($578)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $T=$579; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $580=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $581=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $582=(($581)|0)==31; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($582) { __label__ = 90; break; } else { __label__ = 91; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 90: + var $591 = 0;__label__ = 92; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 91: + var $585=$I7; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $586=$585 >>> 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $587=((($586)+(8))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $588=((($587)-(2))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $589=(((31)-($588))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $591 = $589;__label__ = 92; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 92: + var $591; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $592=$580 << $591; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $K8=$592; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 93; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 93: + var $594=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $595=(($594+4)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $596=HEAP32[(($595)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $597=$596 & -8; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $598=$qsize; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $599=(($597)|0)!=(($598)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($599) { __label__ = 94; break; } else { __label__ = 100; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 94: + var $601=$K8; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $602=$601 >>> 31; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $603=$602 & 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $604=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $605=(($604+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $606=(($605+($603<<2))|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $C=$606; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $607=$K8; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $608=$607 << 1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $K8=$608; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $609=$C; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $610=HEAP32[(($609)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $611=(($610)|0)!=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($611) { __label__ = 95; break; } else { __label__ = 96; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 95: + var $613=$C; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $614=HEAP32[(($613)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $T=$614; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 99; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 96: + var $616=$C; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $617=$616; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $618=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $619=(($618+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $620=HEAP32[(($619)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $621=(($617)>>>0) >= (($620)>>>0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $622=(($621)&1); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $623=(($622)==(1)); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $624=(($623)|0)!=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($624) { __label__ = 97; break; } else { __label__ = 98; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 97: + var $626=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $627=$C; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($627)>>2)]=$626; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $628=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $629=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $630=(($629+24)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($630)>>2)]=$628; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $631=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $632=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $633=(($632+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($633)>>2)]=$631; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $634=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $635=(($634+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($635)>>2)]=$631; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 106; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 98: + _abort(); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 99: + __label__ = 105; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 100: + var $639=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $640=(($639+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $641=HEAP32[(($640)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + $F9=$641; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $642=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $643=$642; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $644=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $645=(($644+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $646=HEAP32[(($645)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $647=(($643)>>>0) >= (($646)>>>0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + if ($647) { __label__ = 101; break; } else { var $656 = 0;__label__ = 102; break; } //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 101: + var $649=$F9; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $650=$649; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $651=$1; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $652=(($651+16)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $653=HEAP32[(($652)>>2)]; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $654=(($650)>>>0) >= (($653)>>>0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $656 = $654;__label__ = 102; break; + case 102: + var $656; + var $657=(($656)&1); + var $658=(($657)==(1)); + var $659=(($658)|0)!=0; + if ($659) { __label__ = 103; break; } else { __label__ = 104; break; } + case 103: + var $661=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $662=$F9; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $663=(($662+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($663)>>2)]=$661; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $664=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $665=(($664+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($665)>>2)]=$661; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $666=$F9; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $667=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $668=(($667+8)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($668)>>2)]=$666; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $669=$T; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $670=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $671=(($670+12)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($671)>>2)]=$669; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $672=$TP5; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + var $673=(($672+24)|0); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($673)>>2)]=0; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 106; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 104: + _abort(); //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 105: + __label__ = 93; break; //@line 3811 "/root/emscripten/system/lib/dlmalloc.c" + case 106: + __label__ = 107; break; + case 107: + __label__ = 108; break; + case 108: + __label__ = 109; break; + case 109: + __label__ = 110; break; + case 110: + var $681=$p; //@line 3816 "/root/emscripten/system/lib/dlmalloc.c" + var $682=$681; //@line 3816 "/root/emscripten/system/lib/dlmalloc.c" + var $683=(($682+8)|0); //@line 3816 "/root/emscripten/system/lib/dlmalloc.c" + ; + return $683; //@line 3816 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_prepend_alloc["X"]=1; + +function _add_segment($m, $tbase, $tsize, $mmapped) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $old_top; + var $oldsp; + var $old_end; + var $ssize; + var $rawsp; + var $offset; + var $asp; + var $csp; + var $sp; + var $ss; + var $tnext; + var $p; + var $nfences; + var $nextp; + var $q; + var $psize; + var $tn; + var $I; + var $B; + var $F; + var $TP; + var $H; + var $I1; + var $X; + var $Y; + var $N; + var $K; + var $T; + var $K2; + var $C; + var $F3; + $1=$m; + $2=$tbase; + $3=$tsize; + $4=$mmapped; + var $5=$1; //@line 3822 "/root/emscripten/system/lib/dlmalloc.c" + var $6=(($5+24)|0); //@line 3822 "/root/emscripten/system/lib/dlmalloc.c" + var $7=HEAP32[(($6)>>2)]; //@line 3822 "/root/emscripten/system/lib/dlmalloc.c" + var $8=$7; //@line 3822 "/root/emscripten/system/lib/dlmalloc.c" + $old_top=$8; //@line 3822 "/root/emscripten/system/lib/dlmalloc.c" + var $9=$1; //@line 3823 "/root/emscripten/system/lib/dlmalloc.c" + var $10=$old_top; //@line 3823 "/root/emscripten/system/lib/dlmalloc.c" + var $11=_segment_holding($9, $10); //@line 3823 "/root/emscripten/system/lib/dlmalloc.c" + $oldsp=$11; //@line 3823 "/root/emscripten/system/lib/dlmalloc.c" + var $12=$oldsp; //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $13=(($12)|0); //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $14=HEAP32[(($13)>>2)]; //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $15=$oldsp; //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $16=(($15+4)|0); //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $17=HEAP32[(($16)>>2)]; //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + var $18=(($14+$17)|0); //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + $old_end=$18; //@line 3824 "/root/emscripten/system/lib/dlmalloc.c" + $ssize=24; //@line 3825 "/root/emscripten/system/lib/dlmalloc.c" + var $19=$old_end; //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $20=$ssize; //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $21=((($20)+(16))|0); //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $22=((($21)+(7))|0); //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $23=(((-$22))|0); //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $24=(($19+$23)|0); //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + $rawsp=$24; //@line 3826 "/root/emscripten/system/lib/dlmalloc.c" + var $25=$rawsp; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $26=(($25+8)|0); //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $27=$26; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $28=$27 & 7; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $29=(($28)|0)==0; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + if ($29) { __label__ = 3; break; } else { __label__ = 4; break; } //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + case 3: + var $39 = 0;__label__ = 5; break; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + case 4: + var $32=$rawsp; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $33=(($32+8)|0); //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $34=$33; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $35=$34 & 7; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $36=(((8)-($35))|0); //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $37=$36 & 7; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $39 = $37;__label__ = 5; break; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + case 5: + var $39; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + $offset=$39; //@line 3827 "/root/emscripten/system/lib/dlmalloc.c" + var $40=$rawsp; //@line 3828 "/root/emscripten/system/lib/dlmalloc.c" + var $41=$offset; //@line 3828 "/root/emscripten/system/lib/dlmalloc.c" + var $42=(($40+$41)|0); //@line 3828 "/root/emscripten/system/lib/dlmalloc.c" + $asp=$42; //@line 3828 "/root/emscripten/system/lib/dlmalloc.c" + var $43=$asp; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $44=$old_top; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $45=(($44+16)|0); //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $46=(($43)>>>0) < (($45)>>>0); //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + if ($46) { __label__ = 6; break; } else { __label__ = 7; break; } //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + case 6: + var $48=$old_top; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $52 = $48;__label__ = 8; break; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + case 7: + var $50=$asp; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $52 = $50;__label__ = 8; break; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + case 8: + var $52; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + $csp=$52; //@line 3829 "/root/emscripten/system/lib/dlmalloc.c" + var $53=$csp; //@line 3830 "/root/emscripten/system/lib/dlmalloc.c" + var $54=$53; //@line 3830 "/root/emscripten/system/lib/dlmalloc.c" + $sp=$54; //@line 3830 "/root/emscripten/system/lib/dlmalloc.c" + var $55=$sp; //@line 3831 "/root/emscripten/system/lib/dlmalloc.c" + var $56=$55; //@line 3831 "/root/emscripten/system/lib/dlmalloc.c" + var $57=(($56+8)|0); //@line 3831 "/root/emscripten/system/lib/dlmalloc.c" + var $58=$57; //@line 3831 "/root/emscripten/system/lib/dlmalloc.c" + $ss=$58; //@line 3831 "/root/emscripten/system/lib/dlmalloc.c" + var $59=$sp; //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + var $60=$59; //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + var $61=$ssize; //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + var $62=(($60+$61)|0); //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + var $63=$62; //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + $tnext=$63; //@line 3832 "/root/emscripten/system/lib/dlmalloc.c" + var $64=$tnext; //@line 3833 "/root/emscripten/system/lib/dlmalloc.c" + $p=$64; //@line 3833 "/root/emscripten/system/lib/dlmalloc.c" + $nfences=0; //@line 3834 "/root/emscripten/system/lib/dlmalloc.c" + var $65=$1; //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + var $66=$2; //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + var $67=$66; //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + var $68=$3; //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + var $69=((($68)-(40))|0); //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + _init_top($65, $67, $69); //@line 3837 "/root/emscripten/system/lib/dlmalloc.c" + var $70=$ssize; //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + var $71=$70 | 1; //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + var $72=$71 | 2; //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + var $73=$sp; //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + var $74=(($73+4)|0); //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($74)>>2)]=$72; //@line 3841 "/root/emscripten/system/lib/dlmalloc.c" + var $75=$ss; //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + var $76=$1; //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + var $77=(($76+444)|0); //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + var $78=$75; //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + var $79=$77; //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + assert(16 % 1 === 0, 'memcpy given ' + 16 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');HEAP32[(($78)>>2)]=HEAP32[(($79)>>2)];HEAP32[((($78)+(4))>>2)]=HEAP32[((($79)+(4))>>2)];HEAP32[((($78)+(8))>>2)]=HEAP32[((($79)+(8))>>2)];HEAP32[((($78)+(12))>>2)]=HEAP32[((($79)+(12))>>2)]; //@line 3842 "/root/emscripten/system/lib/dlmalloc.c" + var $80=$2; //@line 3843 "/root/emscripten/system/lib/dlmalloc.c" + var $81=$1; //@line 3843 "/root/emscripten/system/lib/dlmalloc.c" + var $82=(($81+444)|0); //@line 3843 "/root/emscripten/system/lib/dlmalloc.c" + var $83=(($82)|0); //@line 3843 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($83)>>2)]=$80; //@line 3843 "/root/emscripten/system/lib/dlmalloc.c" + var $84=$3; //@line 3844 "/root/emscripten/system/lib/dlmalloc.c" + var $85=$1; //@line 3844 "/root/emscripten/system/lib/dlmalloc.c" + var $86=(($85+444)|0); //@line 3844 "/root/emscripten/system/lib/dlmalloc.c" + var $87=(($86+4)|0); //@line 3844 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($87)>>2)]=$84; //@line 3844 "/root/emscripten/system/lib/dlmalloc.c" + var $88=$4; //@line 3845 "/root/emscripten/system/lib/dlmalloc.c" + var $89=$1; //@line 3845 "/root/emscripten/system/lib/dlmalloc.c" + var $90=(($89+444)|0); //@line 3845 "/root/emscripten/system/lib/dlmalloc.c" + var $91=(($90+12)|0); //@line 3845 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($91)>>2)]=$88; //@line 3845 "/root/emscripten/system/lib/dlmalloc.c" + var $92=$ss; //@line 3846 "/root/emscripten/system/lib/dlmalloc.c" + var $93=$1; //@line 3846 "/root/emscripten/system/lib/dlmalloc.c" + var $94=(($93+444)|0); //@line 3846 "/root/emscripten/system/lib/dlmalloc.c" + var $95=(($94+8)|0); //@line 3846 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($95)>>2)]=$92; //@line 3846 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 9; break; //@line 3849 "/root/emscripten/system/lib/dlmalloc.c" + case 9: + var $97=$p; //@line 3850 "/root/emscripten/system/lib/dlmalloc.c" + var $98=$97; //@line 3850 "/root/emscripten/system/lib/dlmalloc.c" + var $99=(($98+4)|0); //@line 3850 "/root/emscripten/system/lib/dlmalloc.c" + var $100=$99; //@line 3850 "/root/emscripten/system/lib/dlmalloc.c" + $nextp=$100; //@line 3850 "/root/emscripten/system/lib/dlmalloc.c" + var $101=$p; //@line 3851 "/root/emscripten/system/lib/dlmalloc.c" + var $102=(($101+4)|0); //@line 3851 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($102)>>2)]=7; //@line 3851 "/root/emscripten/system/lib/dlmalloc.c" + var $103=$nfences; //@line 3852 "/root/emscripten/system/lib/dlmalloc.c" + var $104=((($103)+(1))|0); //@line 3852 "/root/emscripten/system/lib/dlmalloc.c" + $nfences=$104; //@line 3852 "/root/emscripten/system/lib/dlmalloc.c" + var $105=$nextp; //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + var $106=(($105+4)|0); //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + var $107=$106; //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + var $108=$old_end; //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + var $109=(($107)>>>0) < (($108)>>>0); //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + if ($109) { __label__ = 10; break; } else { __label__ = 11; break; } //@line 3853 "/root/emscripten/system/lib/dlmalloc.c" + case 10: + var $111=$nextp; //@line 3854 "/root/emscripten/system/lib/dlmalloc.c" + $p=$111; //@line 3854 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 12; break; //@line 3854 "/root/emscripten/system/lib/dlmalloc.c" + case 11: + __label__ = 13; break; //@line 3856 "/root/emscripten/system/lib/dlmalloc.c" + case 12: + __label__ = 9; break; //@line 3857 "/root/emscripten/system/lib/dlmalloc.c" + case 13: + var $115=$csp; //@line 3861 "/root/emscripten/system/lib/dlmalloc.c" + var $116=$old_top; //@line 3861 "/root/emscripten/system/lib/dlmalloc.c" + var $117=(($115)|0)!=(($116)|0); //@line 3861 "/root/emscripten/system/lib/dlmalloc.c" + if ($117) { __label__ = 14; break; } else { __label__ = 50; break; } //@line 3861 "/root/emscripten/system/lib/dlmalloc.c" + case 14: + var $119=$old_top; //@line 3862 "/root/emscripten/system/lib/dlmalloc.c" + var $120=$119; //@line 3862 "/root/emscripten/system/lib/dlmalloc.c" + $q=$120; //@line 3862 "/root/emscripten/system/lib/dlmalloc.c" + var $121=$csp; //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + var $122=$old_top; //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + var $123=$121; //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + var $124=$122; //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + var $125=((($123)-($124))|0); //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + $psize=$125; //@line 3863 "/root/emscripten/system/lib/dlmalloc.c" + var $126=$q; //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + var $127=$126; //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + var $128=$psize; //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + var $129=(($127+$128)|0); //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + var $130=$129; //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + $tn=$130; //@line 3864 "/root/emscripten/system/lib/dlmalloc.c" + var $131=$tn; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $132=(($131+4)|0); //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $133=HEAP32[(($132)>>2)]; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $134=$133 & -2; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($132)>>2)]=$134; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $135=$psize; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $136=$135 | 1; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $137=$q; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $138=(($137+4)|0); //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($138)>>2)]=$136; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $139=$psize; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $140=$q; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $141=$140; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $142=$psize; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $143=(($141+$142)|0); //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $144=$143; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $145=(($144)|0); //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($145)>>2)]=$139; //@line 3865 "/root/emscripten/system/lib/dlmalloc.c" + var $146=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $147=$146 >>> 3; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $148=(($147)>>>0) < 32; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($148) { __label__ = 15; break; } else { __label__ = 22; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 15: + var $150=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $151=$150 >>> 3; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $I=$151; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $152=$I; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $153=$152 << 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $154=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $155=(($154+40)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $156=(($155+($153<<2))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $157=$156; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $158=$157; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $B=$158; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $159=$B; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $F=$159; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $160=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $161=(($160)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $162=HEAP32[(($161)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $163=$I; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $164=1 << $163; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $165=$162 & $164; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $166=(($165)|0)!=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($166) { __label__ = 17; break; } else { __label__ = 16; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 16: + var $168=$I; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $169=1 << $168; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $170=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $171=(($170)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $172=HEAP32[(($171)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $173=$172 | $169; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($171)>>2)]=$173; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 21; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 17: + var $175=$B; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $176=(($175+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $177=HEAP32[(($176)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $178=$177; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $179=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $180=(($179+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $181=HEAP32[(($180)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $182=(($178)>>>0) >= (($181)>>>0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $183=(($182)&1); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $184=(($183)==(1)); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $185=(($184)|0)!=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($185) { __label__ = 18; break; } else { __label__ = 19; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 18: + var $187=$B; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $188=(($187+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $189=HEAP32[(($188)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $F=$189; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 20; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 19: + _abort(); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 20: + __label__ = 21; break; + case 21: + var $193=$q; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $194=$B; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $195=(($194+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($195)>>2)]=$193; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $196=$q; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $197=$F; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $198=(($197+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($198)>>2)]=$196; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $199=$F; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $200=$q; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $201=(($200+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($201)>>2)]=$199; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $202=$B; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $203=$q; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $204=(($203+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($204)>>2)]=$202; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 49; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 22: + var $206=$q; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $207=$206; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $TP=$207; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $208=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $209=$208 >>> 8; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $X=$209; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $210=$X; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $211=(($210)|0)==0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($211) { __label__ = 23; break; } else { __label__ = 24; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 23: + $I1=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 28; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 24: + var $214=$X; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $215=(($214)>>>0) > 65535; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($215) { __label__ = 25; break; } else { __label__ = 26; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 25: + $I1=31; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 27; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 26: + var $218=$X; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$218; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $219=$Y; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $220=((($219)-(256))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $221=$220 >>> 16; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $222=$221 & 8; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $N=$222; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $223=$N; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $224=$Y; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $225=$224 << $223; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$225; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $226=((($225)-(4096))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $227=$226 >>> 16; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $228=$227 & 4; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $K=$228; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $229=$K; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $230=$N; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $231=((($230)+($229))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $N=$231; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $232=$K; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $233=$Y; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $234=$233 << $232; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$234; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $235=((($234)-(16384))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $236=$235 >>> 16; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $237=$236 & 2; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $K=$237; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $238=$N; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $239=((($238)+($237))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $N=$239; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $240=$N; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $241=(((14)-($240))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $242=$K; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $243=$Y; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $244=$243 << $242; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $Y=$244; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $245=$244 >>> 15; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $246=((($241)+($245))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $K=$246; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $247=$K; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $248=$247 << 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $249=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $250=$K; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $251=((($250)+(7))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $252=$249 >>> (($251)>>>0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $253=$252 & 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $254=((($248)+($253))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $I1=$254; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 27; break; + case 27: + __label__ = 28; break; + case 28: + var $257=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $258=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $259=(($258+304)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $260=(($259+($257<<2))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $H=$260; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $261=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $262=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $263=(($262+28)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($263)>>2)]=$261; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $264=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $265=(($264+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $266=(($265+4)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($266)>>2)]=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $267=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $268=(($267+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $269=(($268)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($269)>>2)]=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $270=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $271=(($270+4)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $272=HEAP32[(($271)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $273=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $274=1 << $273; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $275=$272 & $274; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $276=(($275)|0)!=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($276) { __label__ = 30; break; } else { __label__ = 29; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 29: + var $278=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $279=1 << $278; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $280=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $281=(($280+4)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $282=HEAP32[(($281)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $283=$282 | $279; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($281)>>2)]=$283; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $284=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $285=$H; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($285)>>2)]=$284; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $286=$H; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $287=$286; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $288=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $289=(($288+24)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($289)>>2)]=$287; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $290=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $291=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $292=(($291+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($292)>>2)]=$290; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $293=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $294=(($293+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($294)>>2)]=$290; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 48; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 30: + var $296=$H; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $297=HEAP32[(($296)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $T=$297; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $298=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $299=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $300=(($299)|0)==31; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($300) { __label__ = 31; break; } else { __label__ = 32; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 31: + var $309 = 0;__label__ = 33; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 32: + var $303=$I1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $304=$303 >>> 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $305=((($304)+(8))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $306=((($305)-(2))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $307=(((31)-($306))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $309 = $307;__label__ = 33; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 33: + var $309; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $310=$298 << $309; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$310; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 34; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 34: + var $312=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $313=(($312+4)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $314=HEAP32[(($313)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $315=$314 & -8; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $316=$psize; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $317=(($315)|0)!=(($316)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($317) { __label__ = 35; break; } else { __label__ = 41; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 35: + var $319=$K2; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $320=$319 >>> 31; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $321=$320 & 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $322=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $323=(($322+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $324=(($323+($321<<2))|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $C=$324; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $325=$K2; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $326=$325 << 1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $K2=$326; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $327=$C; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $328=HEAP32[(($327)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $329=(($328)|0)!=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($329) { __label__ = 36; break; } else { __label__ = 37; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 36: + var $331=$C; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $332=HEAP32[(($331)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $T=$332; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 40; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 37: + var $334=$C; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $335=$334; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $336=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $337=(($336+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $338=HEAP32[(($337)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $339=(($335)>>>0) >= (($338)>>>0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $340=(($339)&1); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $341=(($340)==(1)); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $342=(($341)|0)!=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($342) { __label__ = 38; break; } else { __label__ = 39; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 38: + var $344=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $345=$C; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($345)>>2)]=$344; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $346=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $347=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $348=(($347+24)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($348)>>2)]=$346; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $349=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $350=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $351=(($350+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($351)>>2)]=$349; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $352=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $353=(($352+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($353)>>2)]=$349; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 47; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 39: + _abort(); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 40: + __label__ = 46; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 41: + var $357=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $358=(($357+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $359=HEAP32[(($358)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + $F3=$359; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $360=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $361=$360; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $362=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $363=(($362+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $364=HEAP32[(($363)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $365=(($361)>>>0) >= (($364)>>>0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + if ($365) { __label__ = 42; break; } else { var $374 = 0;__label__ = 43; break; } //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 42: + var $367=$F3; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $368=$367; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $369=$1; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $370=(($369+16)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $371=HEAP32[(($370)>>2)]; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $372=(($368)>>>0) >= (($371)>>>0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $374 = $372;__label__ = 43; break; + case 43: + var $374; + var $375=(($374)&1); + var $376=(($375)==(1)); + var $377=(($376)|0)!=0; + if ($377) { __label__ = 44; break; } else { __label__ = 45; break; } + case 44: + var $379=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $380=$F3; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $381=(($380+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($381)>>2)]=$379; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $382=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $383=(($382+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($383)>>2)]=$379; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $384=$F3; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $385=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $386=(($385+8)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($386)>>2)]=$384; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $387=$T; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $388=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $389=(($388+12)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($389)>>2)]=$387; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $390=$TP; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + var $391=(($390+24)|0); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + HEAP32[(($391)>>2)]=0; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + __label__ = 47; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 45: + _abort(); //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + throw "Reached an unreachable!" //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 46: + __label__ = 34; break; //@line 3866 "/root/emscripten/system/lib/dlmalloc.c" + case 47: + __label__ = 48; break; + case 48: + __label__ = 49; break; + case 49: + __label__ = 50; break; //@line 3867 "/root/emscripten/system/lib/dlmalloc.c" + case 50: + ; + return; //@line 3870 "/root/emscripten/system/lib/dlmalloc.c" + default: assert(0, "bad label: " + __label__); + } +} +_add_segment["X"]=1; + +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. +// TODO: strip out parts of this we do not need + +//======= begin closure i64 code ======= + +// Copyright 2009 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview Defines a Long class for representing a 64-bit two's-complement + * integer value, which faithfully simulates the behavior of a Java "long". This + * implementation is derived from LongLib in GWT. + * + */ + +var i64Math = (function() { // Emscripten wrapper + var goog = { math: {} }; + + + /** + * Constructs a 64-bit two's-complement integer, given its low and high 32-bit + * values as *signed* integers. See the from* functions below for more + * convenient ways of constructing Longs. + * + * The internal representation of a long is the two given signed, 32-bit values. + * We use 32-bit pieces because these are the size of integers on which + * Javascript performs bit-operations. For operations like addition and + * multiplication, we split each number into 16-bit pieces, which can easily be + * multiplied within Javascript's floating-point representation without overflow + * or change in sign. + * + * In the algorithms below, we frequently reduce the negative case to the + * positive case by negating the input(s) and then post-processing the result. + * Note that we must ALWAYS check specially whether those values are MIN_VALUE + * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as + * a positive number, it overflows back into a negative). Not handling this + * case would often result in infinite recursion. + * + * @param {number} low The low (signed) 32 bits of the long. + * @param {number} high The high (signed) 32 bits of the long. + * @constructor + */ + goog.math.Long = function(low, high) { + /** + * @type {number} + * @private + */ + this.low_ = low | 0; // force into 32 signed bits. + + /** + * @type {number} + * @private + */ + this.high_ = high | 0; // force into 32 signed bits. + }; + + + // NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the + // from* methods on which they depend. + + + /** + * A cache of the Long representations of small integer values. + * @type {!Object} + * @private + */ + goog.math.Long.IntCache_ = {}; + + + /** + * Returns a Long representing the given (32-bit) integer value. + * @param {number} value The 32-bit integer in question. + * @return {!goog.math.Long} The corresponding Long value. + */ + goog.math.Long.fromInt = function(value) { + if (-128 <= value && value < 128) { + var cachedObj = goog.math.Long.IntCache_[value]; + if (cachedObj) { + return cachedObj; + } + } + + var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0); + if (-128 <= value && value < 128) { + goog.math.Long.IntCache_[value] = obj; + } + return obj; + }; + + + /** + * Returns a Long representing the given value, provided that it is a finite + * number. Otherwise, zero is returned. + * @param {number} value The number in question. + * @return {!goog.math.Long} The corresponding Long value. + */ + goog.math.Long.fromNumber = function(value) { + if (isNaN(value) || !isFinite(value)) { + return goog.math.Long.ZERO; + } else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) { + return goog.math.Long.MIN_VALUE; + } else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) { + return goog.math.Long.MAX_VALUE; + } else if (value < 0) { + return goog.math.Long.fromNumber(-value).negate(); + } else { + return new goog.math.Long( + (value % goog.math.Long.TWO_PWR_32_DBL_) | 0, + (value / goog.math.Long.TWO_PWR_32_DBL_) | 0); + } + }; + + + /** + * Returns a Long representing the 64-bit integer that comes by concatenating + * the given high and low bits. Each is assumed to use 32 bits. + * @param {number} lowBits The low 32-bits. + * @param {number} highBits The high 32-bits. + * @return {!goog.math.Long} The corresponding Long value. + */ + goog.math.Long.fromBits = function(lowBits, highBits) { + return new goog.math.Long(lowBits, highBits); + }; + + + /** + * Returns a Long representation of the given string, written using the given + * radix. + * @param {string} str The textual representation of the Long. + * @param {number=} opt_radix The radix in which the text is written. + * @return {!goog.math.Long} The corresponding Long value. + */ + goog.math.Long.fromString = function(str, opt_radix) { + if (str.length == 0) { + throw Error('number format error: empty string'); + } + + var radix = opt_radix || 10; + if (radix < 2 || 36 < radix) { + throw Error('radix out of range: ' + radix); + } + + if (str.charAt(0) == '-') { + return goog.math.Long.fromString(str.substring(1), radix).negate(); + } else if (str.indexOf('-') >= 0) { + throw Error('number format error: interior "-" character: ' + str); + } + + // Do several (8) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8)); + + var result = goog.math.Long.ZERO; + for (var i = 0; i < str.length; i += 8) { + var size = Math.min(8, str.length - i); + var value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + var power = goog.math.Long.fromNumber(Math.pow(radix, size)); + result = result.multiply(power).add(goog.math.Long.fromNumber(value)); + } else { + result = result.multiply(radixToPower); + result = result.add(goog.math.Long.fromNumber(value)); + } + } + return result; + }; + + + // NOTE: the compiler should inline these constant values below and then remove + // these variables, so there should be no runtime penalty for these. + + + /** + * Number used repeated below in calculations. This must appear before the + * first call to any from* function below. + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_32_DBL_ = + goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_31_DBL_ = + goog.math.Long.TWO_PWR_32_DBL_ / 2; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_48_DBL_ = + goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_64_DBL_ = + goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_; + + + /** + * @type {number} + * @private + */ + goog.math.Long.TWO_PWR_63_DBL_ = + goog.math.Long.TWO_PWR_64_DBL_ / 2; + + + /** @type {!goog.math.Long} */ + goog.math.Long.ZERO = goog.math.Long.fromInt(0); + + + /** @type {!goog.math.Long} */ + goog.math.Long.ONE = goog.math.Long.fromInt(1); + + + /** @type {!goog.math.Long} */ + goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1); + + + /** @type {!goog.math.Long} */ + goog.math.Long.MAX_VALUE = + goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0); + + + /** @type {!goog.math.Long} */ + goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0); + + + /** + * @type {!goog.math.Long} + * @private + */ + goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24); + + + /** @return {number} The value, assuming it is a 32-bit integer. */ + goog.math.Long.prototype.toInt = function() { + return this.low_; + }; + + + /** @return {number} The closest floating-point representation to this value. */ + goog.math.Long.prototype.toNumber = function() { + return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ + + this.getLowBitsUnsigned(); + }; + + + /** + * @param {number=} opt_radix The radix in which the text should be written. + * @return {string} The textual representation of this value. + */ + goog.math.Long.prototype.toString = function(opt_radix) { + var radix = opt_radix || 10; + if (radix < 2 || 36 < radix) { + throw Error('radix out of range: ' + radix); + } + + if (this.isZero()) { + return '0'; + } + + if (this.isNegative()) { + if (this.equals(goog.math.Long.MIN_VALUE)) { + // We need to change the Long value before it can be negated, so we remove + // the bottom-most digit in this base and then recurse to do the rest. + var radixLong = goog.math.Long.fromNumber(radix); + var div = this.div(radixLong); + var rem = div.multiply(radixLong).subtract(this); + return div.toString(radix) + rem.toInt().toString(radix); + } else { + return '-' + this.negate().toString(radix); + } + } + + // Do several (6) digits each time through the loop, so as to + // minimize the calls to the very expensive emulated div. + var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6)); + + var rem = this; + var result = ''; + while (true) { + var remDiv = rem.div(radixToPower); + var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt(); + var digits = intval.toString(radix); + + rem = remDiv; + if (rem.isZero()) { + return digits + result; + } else { + while (digits.length < 6) { + digits = '0' + digits; + } + result = '' + digits + result; + } + } + }; + + + /** @return {number} The high 32-bits as a signed value. */ + goog.math.Long.prototype.getHighBits = function() { + return this.high_; + }; + + + /** @return {number} The low 32-bits as a signed value. */ + goog.math.Long.prototype.getLowBits = function() { + return this.low_; + }; + + + /** @return {number} The low 32-bits as an unsigned value. */ + goog.math.Long.prototype.getLowBitsUnsigned = function() { + return (this.low_ >= 0) ? + this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_; + }; + + + /** + * @return {number} Returns the number of bits needed to represent the absolute + * value of this Long. + */ + goog.math.Long.prototype.getNumBitsAbs = function() { + if (this.isNegative()) { + if (this.equals(goog.math.Long.MIN_VALUE)) { + return 64; + } else { + return this.negate().getNumBitsAbs(); + } + } else { + var val = this.high_ != 0 ? this.high_ : this.low_; + for (var bit = 31; bit > 0; bit--) { + if ((val & (1 << bit)) != 0) { + break; + } + } + return this.high_ != 0 ? bit + 33 : bit + 1; + } + }; + + + /** @return {boolean} Whether this value is zero. */ + goog.math.Long.prototype.isZero = function() { + return this.high_ == 0 && this.low_ == 0; + }; + + + /** @return {boolean} Whether this value is negative. */ + goog.math.Long.prototype.isNegative = function() { + return this.high_ < 0; + }; + + + /** @return {boolean} Whether this value is odd. */ + goog.math.Long.prototype.isOdd = function() { + return (this.low_ & 1) == 1; + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long equals the other. + */ + goog.math.Long.prototype.equals = function(other) { + return (this.high_ == other.high_) && (this.low_ == other.low_); + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long does not equal the other. + */ + goog.math.Long.prototype.notEquals = function(other) { + return (this.high_ != other.high_) || (this.low_ != other.low_); + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long is less than the other. + */ + goog.math.Long.prototype.lessThan = function(other) { + return this.compare(other) < 0; + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long is less than or equal to the other. + */ + goog.math.Long.prototype.lessThanOrEqual = function(other) { + return this.compare(other) <= 0; + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long is greater than the other. + */ + goog.math.Long.prototype.greaterThan = function(other) { + return this.compare(other) > 0; + }; + + + /** + * @param {goog.math.Long} other Long to compare against. + * @return {boolean} Whether this Long is greater than or equal to the other. + */ + goog.math.Long.prototype.greaterThanOrEqual = function(other) { + return this.compare(other) >= 0; + }; + + + /** + * Compares this Long with the given one. + * @param {goog.math.Long} other Long to compare against. + * @return {number} 0 if they are the same, 1 if the this is greater, and -1 + * if the given one is greater. + */ + goog.math.Long.prototype.compare = function(other) { + if (this.equals(other)) { + return 0; + } + + var thisNeg = this.isNegative(); + var otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) { + return -1; + } + if (!thisNeg && otherNeg) { + return 1; + } + + // at this point, the signs are the same, so subtraction will not overflow + if (this.subtract(other).isNegative()) { + return -1; + } else { + return 1; + } + }; + + + /** @return {!goog.math.Long} The negation of this value. */ + goog.math.Long.prototype.negate = function() { + if (this.equals(goog.math.Long.MIN_VALUE)) { + return goog.math.Long.MIN_VALUE; + } else { + return this.not().add(goog.math.Long.ONE); + } + }; + + + /** + * Returns the sum of this and the given Long. + * @param {goog.math.Long} other Long to add to this one. + * @return {!goog.math.Long} The sum of this and the given Long. + */ + goog.math.Long.prototype.add = function(other) { + // Divide each number into 4 chunks of 16 bits, and then sum the chunks. + + var a48 = this.high_ >>> 16; + var a32 = this.high_ & 0xFFFF; + var a16 = this.low_ >>> 16; + var a00 = this.low_ & 0xFFFF; + + var b48 = other.high_ >>> 16; + var b32 = other.high_ & 0xFFFF; + var b16 = other.low_ >>> 16; + var b00 = other.low_ & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 + b48; + c48 &= 0xFFFF; + return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32); + }; + + + /** + * Returns the difference of this and the given Long. + * @param {goog.math.Long} other Long to subtract from this. + * @return {!goog.math.Long} The difference of this and the given Long. + */ + goog.math.Long.prototype.subtract = function(other) { + return this.add(other.negate()); + }; + + + /** + * Returns the product of this and the given long. + * @param {goog.math.Long} other Long to multiply with this. + * @return {!goog.math.Long} The product of this and the other. + */ + goog.math.Long.prototype.multiply = function(other) { + if (this.isZero()) { + return goog.math.Long.ZERO; + } else if (other.isZero()) { + return goog.math.Long.ZERO; + } + + if (this.equals(goog.math.Long.MIN_VALUE)) { + return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO; + } else if (other.equals(goog.math.Long.MIN_VALUE)) { + return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO; + } + + if (this.isNegative()) { + if (other.isNegative()) { + return this.negate().multiply(other.negate()); + } else { + return this.negate().multiply(other).negate(); + } + } else if (other.isNegative()) { + return this.multiply(other.negate()).negate(); + } + + // If both longs are small, use float multiplication + if (this.lessThan(goog.math.Long.TWO_PWR_24_) && + other.lessThan(goog.math.Long.TWO_PWR_24_)) { + return goog.math.Long.fromNumber(this.toNumber() * other.toNumber()); + } + + // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products. + // We can skip products that would overflow. + + var a48 = this.high_ >>> 16; + var a32 = this.high_ & 0xFFFF; + var a16 = this.low_ >>> 16; + var a00 = this.low_ & 0xFFFF; + + var b48 = other.high_ >>> 16; + var b32 = other.high_ & 0xFFFF; + var b16 = other.low_ >>> 16; + var b00 = other.low_ & 0xFFFF; + + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 0xFFFF; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 0xFFFF; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 0xFFFF; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 0xFFFF; + return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32); + }; + + + /** + * Returns this Long divided by the given one. + * @param {goog.math.Long} other Long by which to divide. + * @return {!goog.math.Long} This Long divided by the given one. + */ + goog.math.Long.prototype.div = function(other) { + if (other.isZero()) { + throw Error('division by zero'); + } else if (this.isZero()) { + return goog.math.Long.ZERO; + } + + if (this.equals(goog.math.Long.MIN_VALUE)) { + if (other.equals(goog.math.Long.ONE) || + other.equals(goog.math.Long.NEG_ONE)) { + return goog.math.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE + } else if (other.equals(goog.math.Long.MIN_VALUE)) { + return goog.math.Long.ONE; + } else { + // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|. + var halfThis = this.shiftRight(1); + var approx = halfThis.div(other).shiftLeft(1); + if (approx.equals(goog.math.Long.ZERO)) { + return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE; + } else { + var rem = this.subtract(other.multiply(approx)); + var result = approx.add(rem.div(other)); + return result; + } + } + } else if (other.equals(goog.math.Long.MIN_VALUE)) { + return goog.math.Long.ZERO; + } + + if (this.isNegative()) { + if (other.isNegative()) { + return this.negate().div(other.negate()); + } else { + return this.negate().div(other).negate(); + } + } else if (other.isNegative()) { + return this.div(other.negate()).negate(); + } + + // Repeat the following until the remainder is less than other: find a + // floating-point that approximates remainder / other *from below*, add this + // into the result, and subtract it from the remainder. It is critical that + // the approximate value is less than or equal to the real value so that the + // remainder never becomes negative. + var res = goog.math.Long.ZERO; + var rem = this; + while (rem.greaterThanOrEqual(other)) { + // Approximate the result of division. This may be a little greater or + // smaller than the actual value. + var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber())); + + // We will tweak the approximate result by changing it in the 48-th digit or + // the smallest non-fractional digit, whichever is larger. + var log2 = Math.ceil(Math.log(approx) / Math.LN2); + var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48); + + // Decrease the approximation until it is smaller than the remainder. Note + // that if it is too large, the product overflows and is negative. + var approxRes = goog.math.Long.fromNumber(approx); + var approxRem = approxRes.multiply(other); + while (approxRem.isNegative() || approxRem.greaterThan(rem)) { + approx -= delta; + approxRes = goog.math.Long.fromNumber(approx); + approxRem = approxRes.multiply(other); + } + + // We know the answer can't be zero... and actually, zero would cause + // infinite recursion since we would make no progress. + if (approxRes.isZero()) { + approxRes = goog.math.Long.ONE; + } + + res = res.add(approxRes); + rem = rem.subtract(approxRem); + } + return res; + }; + + + /** + * Returns this Long modulo the given one. + * @param {goog.math.Long} other Long by which to mod. + * @return {!goog.math.Long} This Long modulo the given one. + */ + goog.math.Long.prototype.modulo = function(other) { + return this.subtract(this.div(other).multiply(other)); + }; + + + /** @return {!goog.math.Long} The bitwise-NOT of this value. */ + goog.math.Long.prototype.not = function() { + return goog.math.Long.fromBits(~this.low_, ~this.high_); + }; + + + /** + * Returns the bitwise-AND of this Long and the given one. + * @param {goog.math.Long} other The Long with which to AND. + * @return {!goog.math.Long} The bitwise-AND of this and the other. + */ + goog.math.Long.prototype.and = function(other) { + return goog.math.Long.fromBits(this.low_ & other.low_, + this.high_ & other.high_); + }; + + + /** + * Returns the bitwise-OR of this Long and the given one. + * @param {goog.math.Long} other The Long with which to OR. + * @return {!goog.math.Long} The bitwise-OR of this and the other. + */ + goog.math.Long.prototype.or = function(other) { + return goog.math.Long.fromBits(this.low_ | other.low_, + this.high_ | other.high_); + }; + + + /** + * Returns the bitwise-XOR of this Long and the given one. + * @param {goog.math.Long} other The Long with which to XOR. + * @return {!goog.math.Long} The bitwise-XOR of this and the other. + */ + goog.math.Long.prototype.xor = function(other) { + return goog.math.Long.fromBits(this.low_ ^ other.low_, + this.high_ ^ other.high_); + }; + + + /** + * Returns this Long with bits shifted to the left by the given amount. + * @param {number} numBits The number of bits by which to shift. + * @return {!goog.math.Long} This shifted to the left by the given amount. + */ + goog.math.Long.prototype.shiftLeft = function(numBits) { + numBits &= 63; + if (numBits == 0) { + return this; + } else { + var low = this.low_; + if (numBits < 32) { + var high = this.high_; + return goog.math.Long.fromBits( + low << numBits, + (high << numBits) | (low >>> (32 - numBits))); + } else { + return goog.math.Long.fromBits(0, low << (numBits - 32)); + } + } + }; + + + /** + * Returns this Long with bits shifted to the right by the given amount. + * @param {number} numBits The number of bits by which to shift. + * @return {!goog.math.Long} This shifted to the right by the given amount. + */ + goog.math.Long.prototype.shiftRight = function(numBits) { + numBits &= 63; + if (numBits == 0) { + return this; + } else { + var high = this.high_; + if (numBits < 32) { + var low = this.low_; + return goog.math.Long.fromBits( + (low >>> numBits) | (high << (32 - numBits)), + high >> numBits); + } else { + return goog.math.Long.fromBits( + high >> (numBits - 32), + high >= 0 ? 0 : -1); + } + } + }; + + + /** + * Returns this Long with bits shifted to the right by the given amount, with + * the new top bits matching the current sign bit. + * @param {number} numBits The number of bits by which to shift. + * @return {!goog.math.Long} This shifted to the right by the given amount, with + * zeros placed into the new leading bits. + */ + goog.math.Long.prototype.shiftRightUnsigned = function(numBits) { + numBits &= 63; + if (numBits == 0) { + return this; + } else { + var high = this.high_; + if (numBits < 32) { + var low = this.low_; + return goog.math.Long.fromBits( + (low >>> numBits) | (high << (32 - numBits)), + high >>> numBits); + } else if (numBits == 32) { + return goog.math.Long.fromBits(high, 0); + } else { + return goog.math.Long.fromBits(high >>> (numBits - 32), 0); + } + } + }; + + //======= begin jsbn ======= + + var navigator = { appName: 'Modern Browser' }; // polyfill a little + + // Copyright (c) 2005 Tom Wu + // All Rights Reserved. + // http://www-cs-students.stanford.edu/~tjw/jsbn/ + + /* + * Copyright (c) 2003-2005 Tom Wu + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL, + * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF + * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT + * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * In addition, the following condition applies: + * + * All redistributions must retain an intact copy of this copyright notice + * and disclaimer. + */ + + // Basic JavaScript BN library - subset useful for RSA encryption. + + // Bits per digit + var dbits; + + // JavaScript engine analysis + var canary = 0xdeadbeefcafe; + var j_lm = ((canary&0xffffff)==0xefcafe); + + // (public) Constructor + function BigInteger(a,b,c) { + if(a != null) + if("number" == typeof a) this.fromNumber(a,b,c); + else if(b == null && "string" != typeof a) this.fromString(a,256); + else this.fromString(a,b); + } + + // return new, unset BigInteger + function nbi() { return new BigInteger(null); } + + // am: Compute w_j += (x*this_i), propagate carries, + // c is initial carry, returns final carry. + // c < 3*dvalue, x < 2*dvalue, this_i < dvalue + // We need to select the fastest one that works in this environment. + + // am1: use a single mult and divide to get the high bits, + // max digit bits should be 26 because + // max internal value = 2*dvalue^2-2*dvalue (< 2^53) + function am1(i,x,w,j,c,n) { + while(--n >= 0) { + var v = x*this[i++]+w[j]+c; + c = Math.floor(v/0x4000000); + w[j++] = v&0x3ffffff; + } + return c; + } + // am2 avoids a big mult-and-extract completely. + // Max digit bits should be <= 30 because we do bitwise ops + // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31) + function am2(i,x,w,j,c,n) { + var xl = x&0x7fff, xh = x>>15; + while(--n >= 0) { + var l = this[i]&0x7fff; + var h = this[i++]>>15; + var m = xh*l+h*xl; + l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff); + c = (l>>>30)+(m>>>15)+xh*h+(c>>>30); + w[j++] = l&0x3fffffff; + } + return c; + } + // Alternately, set max digit bits to 28 since some + // browsers slow down when dealing with 32-bit numbers. + function am3(i,x,w,j,c,n) { + var xl = x&0x3fff, xh = x>>14; + while(--n >= 0) { + var l = this[i]&0x3fff; + var h = this[i++]>>14; + var m = xh*l+h*xl; + l = xl*l+((m&0x3fff)<<14)+w[j]+c; + c = (l>>28)+(m>>14)+xh*h; + w[j++] = l&0xfffffff; + } + return c; + } + if(j_lm && (navigator.appName == "Microsoft Internet Explorer")) { + BigInteger.prototype.am = am2; + dbits = 30; + } + else if(j_lm && (navigator.appName != "Netscape")) { + BigInteger.prototype.am = am1; + dbits = 26; + } + else { // Mozilla/Netscape seems to prefer am3 + BigInteger.prototype.am = am3; + dbits = 28; + } + + BigInteger.prototype.DB = dbits; + BigInteger.prototype.DM = ((1<= 0; --i) r[i] = this[i]; + r.t = this.t; + r.s = this.s; + } + + // (protected) set from integer value x, -DV <= x < DV + function bnpFromInt(x) { + this.t = 1; + this.s = (x<0)?-1:0; + if(x > 0) this[0] = x; + else if(x < -1) this[0] = x+DV; + else this.t = 0; + } + + // return bigint initialized to value + function nbv(i) { var r = nbi(); r.fromInt(i); return r; } + + // (protected) set from string and radix + function bnpFromString(s,b) { + var k; + if(b == 16) k = 4; + else if(b == 8) k = 3; + else if(b == 256) k = 8; // byte array + else if(b == 2) k = 1; + else if(b == 32) k = 5; + else if(b == 4) k = 2; + else { this.fromRadix(s,b); return; } + this.t = 0; + this.s = 0; + var i = s.length, mi = false, sh = 0; + while(--i >= 0) { + var x = (k==8)?s[i]&0xff:intAt(s,i); + if(x < 0) { + if(s.charAt(i) == "-") mi = true; + continue; + } + mi = false; + if(sh == 0) + this[this.t++] = x; + else if(sh+k > this.DB) { + this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<>(this.DB-sh)); + } + else + this[this.t-1] |= x<= this.DB) sh -= this.DB; + } + if(k == 8 && (s[0]&0x80) != 0) { + this.s = -1; + if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)< 0 && this[this.t-1] == c) --this.t; + } + + // (public) return string representation in given radix + function bnToString(b) { + if(this.s < 0) return "-"+this.negate().toString(b); + var k; + if(b == 16) k = 4; + else if(b == 8) k = 3; + else if(b == 2) k = 1; + else if(b == 32) k = 5; + else if(b == 4) k = 2; + else return this.toRadix(b); + var km = (1< 0) { + if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); } + while(i >= 0) { + if(p < k) { + d = (this[i]&((1<>(p+=this.DB-k); + } + else { + d = (this[i]>>(p-=k))&km; + if(p <= 0) { p += this.DB; --i; } + } + if(d > 0) m = true; + if(m) r += int2char(d); + } + } + return m?r:"0"; + } + + // (public) -this + function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; } + + // (public) |this| + function bnAbs() { return (this.s<0)?this.negate():this; } + + // (public) return + if this > a, - if this < a, 0 if equal + function bnCompareTo(a) { + var r = this.s-a.s; + if(r != 0) return r; + var i = this.t; + r = i-a.t; + if(r != 0) return r; + while(--i >= 0) if((r=this[i]-a[i]) != 0) return r; + return 0; + } + + // returns bit length of the integer x + function nbits(x) { + var r = 1, t; + if((t=x>>>16) != 0) { x = t; r += 16; } + if((t=x>>8) != 0) { x = t; r += 8; } + if((t=x>>4) != 0) { x = t; r += 4; } + if((t=x>>2) != 0) { x = t; r += 2; } + if((t=x>>1) != 0) { x = t; r += 1; } + return r; + } + + // (public) return the number of bits in "this" + function bnBitLength() { + if(this.t <= 0) return 0; + return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM)); + } + + // (protected) r = this << n*DB + function bnpDLShiftTo(n,r) { + var i; + for(i = this.t-1; i >= 0; --i) r[i+n] = this[i]; + for(i = n-1; i >= 0; --i) r[i] = 0; + r.t = this.t+n; + r.s = this.s; + } + + // (protected) r = this >> n*DB + function bnpDRShiftTo(n,r) { + for(var i = n; i < this.t; ++i) r[i-n] = this[i]; + r.t = Math.max(this.t-n,0); + r.s = this.s; + } + + // (protected) r = this << n + function bnpLShiftTo(n,r) { + var bs = n%this.DB; + var cbs = this.DB-bs; + var bm = (1<= 0; --i) { + r[i+ds+1] = (this[i]>>cbs)|c; + c = (this[i]&bm)<= 0; --i) r[i] = 0; + r[ds] = c; + r.t = this.t+ds+1; + r.s = this.s; + r.clamp(); + } + + // (protected) r = this >> n + function bnpRShiftTo(n,r) { + r.s = this.s; + var ds = Math.floor(n/this.DB); + if(ds >= this.t) { r.t = 0; return; } + var bs = n%this.DB; + var cbs = this.DB-bs; + var bm = (1<>bs; + for(var i = ds+1; i < this.t; ++i) { + r[i-ds-1] |= (this[i]&bm)<>bs; + } + if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<>= this.DB; + } + if(a.t < this.t) { + c -= a.s; + while(i < this.t) { + c += this[i]; + r[i++] = c&this.DM; + c >>= this.DB; + } + c += this.s; + } + else { + c += this.s; + while(i < a.t) { + c -= a[i]; + r[i++] = c&this.DM; + c >>= this.DB; + } + c -= a.s; + } + r.s = (c<0)?-1:0; + if(c < -1) r[i++] = this.DV+c; + else if(c > 0) r[i++] = c; + r.t = i; + r.clamp(); + } + + // (protected) r = this * a, r != this,a (HAC 14.12) + // "this" should be the larger one if appropriate. + function bnpMultiplyTo(a,r) { + var x = this.abs(), y = a.abs(); + var i = x.t; + r.t = i+y.t; + while(--i >= 0) r[i] = 0; + for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t); + r.s = 0; + r.clamp(); + if(this.s != a.s) BigInteger.ZERO.subTo(r,r); + } + + // (protected) r = this^2, r != this (HAC 14.16) + function bnpSquareTo(r) { + var x = this.abs(); + var i = r.t = 2*x.t; + while(--i >= 0) r[i] = 0; + for(i = 0; i < x.t-1; ++i) { + var c = x.am(i,x[i],r,2*i,0,1); + if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) { + r[i+x.t] -= x.DV; + r[i+x.t+1] = 1; + } + } + if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1); + r.s = 0; + r.clamp(); + } + + // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20) + // r != q, this != m. q or r may be null. + function bnpDivRemTo(m,q,r) { + var pm = m.abs(); + if(pm.t <= 0) return; + var pt = this.abs(); + if(pt.t < pm.t) { + if(q != null) q.fromInt(0); + if(r != null) this.copyTo(r); + return; + } + if(r == null) r = nbi(); + var y = nbi(), ts = this.s, ms = m.s; + var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus + if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); } + else { pm.copyTo(y); pt.copyTo(r); } + var ys = y.t; + var y0 = y[ys-1]; + if(y0 == 0) return; + var yt = y0*(1<1)?y[ys-2]>>this.F2:0); + var d1 = this.FV/yt, d2 = (1<= 0) { + r[r.t++] = 1; + r.subTo(t,r); + } + BigInteger.ONE.dlShiftTo(ys,t); + t.subTo(y,y); // "negative" y so we can replace sub with am later + while(y.t < ys) y[y.t++] = 0; + while(--j >= 0) { + // Estimate quotient digit + var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2); + if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out + y.dlShiftTo(j,t); + r.subTo(t,r); + while(r[i] < --qd) r.subTo(t,r); + } + } + if(q != null) { + r.drShiftTo(ys,q); + if(ts != ms) BigInteger.ZERO.subTo(q,q); + } + r.t = ys; + r.clamp(); + if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder + if(ts < 0) BigInteger.ZERO.subTo(r,r); + } + + // (public) this mod a + function bnMod(a) { + var r = nbi(); + this.abs().divRemTo(a,null,r); + if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r); + return r; + } + + // Modular reduction using "classic" algorithm + function Classic(m) { this.m = m; } + function cConvert(x) { + if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m); + else return x; + } + function cRevert(x) { return x; } + function cReduce(x) { x.divRemTo(this.m,null,x); } + function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); } + function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); } + + Classic.prototype.convert = cConvert; + Classic.prototype.revert = cRevert; + Classic.prototype.reduce = cReduce; + Classic.prototype.mulTo = cMulTo; + Classic.prototype.sqrTo = cSqrTo; + + // (protected) return "-1/this % 2^DB"; useful for Mont. reduction + // justification: + // xy == 1 (mod m) + // xy = 1+km + // xy(2-xy) = (1+km)(1-km) + // x[y(2-xy)] = 1-k^2m^2 + // x[y(2-xy)] == 1 (mod m^2) + // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2 + // should reduce x and y(2-xy) by m^2 at each step to keep size bounded. + // JS multiply "overflows" differently from C/C++, so care is needed here. + function bnpInvDigit() { + if(this.t < 1) return 0; + var x = this[0]; + if((x&1) == 0) return 0; + var y = x&3; // y == 1/x mod 2^2 + y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4 + y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8 + y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16 + // last step - calculate inverse mod DV directly; + // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints + y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits + // we really want the negative inverse, and -DV < y < DV + return (y>0)?this.DV-y:-y; + } + + // Montgomery reduction + function Montgomery(m) { + this.m = m; + this.mp = m.invDigit(); + this.mpl = this.mp&0x7fff; + this.mph = this.mp>>15; + this.um = (1<<(m.DB-15))-1; + this.mt2 = 2*m.t; + } + + // xR mod m + function montConvert(x) { + var r = nbi(); + x.abs().dlShiftTo(this.m.t,r); + r.divRemTo(this.m,null,r); + if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r); + return r; + } + + // x/R mod m + function montRevert(x) { + var r = nbi(); + x.copyTo(r); + this.reduce(r); + return r; + } + + // x = x/R mod m (HAC 14.32) + function montReduce(x) { + while(x.t <= this.mt2) // pad x so am has enough room later + x[x.t++] = 0; + for(var i = 0; i < this.m.t; ++i) { + // faster way of calculating u0 = x[i]*mp mod DV + var j = x[i]&0x7fff; + var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM; + // use am to combine the multiply-shift-add into one call + j = i+this.m.t; + x[j] += this.m.am(0,u0,x,i,0,this.m.t); + // propagate carry + while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; } + } + x.clamp(); + x.drShiftTo(this.m.t,x); + if(x.compareTo(this.m) >= 0) x.subTo(this.m,x); + } + + // r = "x^2/R mod m"; x != r + function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); } + + // r = "xy/R mod m"; x,y != r + function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); } + + Montgomery.prototype.convert = montConvert; + Montgomery.prototype.revert = montRevert; + Montgomery.prototype.reduce = montReduce; + Montgomery.prototype.mulTo = montMulTo; + Montgomery.prototype.sqrTo = montSqrTo; + + // (protected) true iff this is even + function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; } + + // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79) + function bnpExp(e,z) { + if(e > 0xffffffff || e < 1) return BigInteger.ONE; + var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1; + g.copyTo(r); + while(--i >= 0) { + z.sqrTo(r,r2); + if((e&(1< 0) z.mulTo(r2,g,r); + else { var t = r; r = r2; r2 = t; } + } + return z.revert(r); + } + + // (public) this^e % m, 0 <= e < 2^32 + function bnModPowInt(e,m) { + var z; + if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m); + return this.exp(e,z); + } + + // protected + BigInteger.prototype.copyTo = bnpCopyTo; + BigInteger.prototype.fromInt = bnpFromInt; + BigInteger.prototype.fromString = bnpFromString; + BigInteger.prototype.clamp = bnpClamp; + BigInteger.prototype.dlShiftTo = bnpDLShiftTo; + BigInteger.prototype.drShiftTo = bnpDRShiftTo; + BigInteger.prototype.lShiftTo = bnpLShiftTo; + BigInteger.prototype.rShiftTo = bnpRShiftTo; + BigInteger.prototype.subTo = bnpSubTo; + BigInteger.prototype.multiplyTo = bnpMultiplyTo; + BigInteger.prototype.squareTo = bnpSquareTo; + BigInteger.prototype.divRemTo = bnpDivRemTo; + BigInteger.prototype.invDigit = bnpInvDigit; + BigInteger.prototype.isEven = bnpIsEven; + BigInteger.prototype.exp = bnpExp; + + // public + BigInteger.prototype.toString = bnToString; + BigInteger.prototype.negate = bnNegate; + BigInteger.prototype.abs = bnAbs; + BigInteger.prototype.compareTo = bnCompareTo; + BigInteger.prototype.bitLength = bnBitLength; + BigInteger.prototype.mod = bnMod; + BigInteger.prototype.modPowInt = bnModPowInt; + + // "constants" + BigInteger.ZERO = nbv(0); + BigInteger.ONE = nbv(1); + + // jsbn2 stuff + + // (protected) convert from radix string + function bnpFromRadix(s,b) { + this.fromInt(0); + if(b == null) b = 10; + var cs = this.chunkSize(b); + var d = Math.pow(b,cs), mi = false, j = 0, w = 0; + for(var i = 0; i < s.length; ++i) { + var x = intAt(s,i); + if(x < 0) { + if(s.charAt(i) == "-" && this.signum() == 0) mi = true; + continue; + } + w = b*w+x; + if(++j >= cs) { + this.dMultiply(d); + this.dAddOffset(w,0); + j = 0; + w = 0; + } + } + if(j > 0) { + this.dMultiply(Math.pow(b,j)); + this.dAddOffset(w,0); + } + if(mi) BigInteger.ZERO.subTo(this,this); + } + + // (protected) return x s.t. r^x < DV + function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); } + + // (public) 0 if this == 0, 1 if this > 0 + function bnSigNum() { + if(this.s < 0) return -1; + else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0; + else return 1; + } + + // (protected) this *= n, this >= 0, 1 < n < DV + function bnpDMultiply(n) { + this[this.t] = this.am(0,n-1,this,0,0,this.t); + ++this.t; + this.clamp(); + } + + // (protected) this += n << w words, this >= 0 + function bnpDAddOffset(n,w) { + if(n == 0) return; + while(this.t <= w) this[this.t++] = 0; + this[w] += n; + while(this[w] >= this.DV) { + this[w] -= this.DV; + if(++w >= this.t) this[this.t++] = 0; + ++this[w]; + } + } + + // (protected) convert to radix string + function bnpToRadix(b) { + if(b == null) b = 10; + if(this.signum() == 0 || b < 2 || b > 36) return "0"; + var cs = this.chunkSize(b); + var a = Math.pow(b,cs); + var d = nbv(a), y = nbi(), z = nbi(), r = ""; + this.divRemTo(d,y,z); + while(y.signum() > 0) { + r = (a+z.intValue()).toString(b).substr(1) + r; + y.divRemTo(d,y,z); + } + return z.intValue().toString(b) + r; + } + + // (public) return value as integer + function bnIntValue() { + if(this.s < 0) { + if(this.t == 1) return this[0]-this.DV; + else if(this.t == 0) return -1; + } + else if(this.t == 1) return this[0]; + else if(this.t == 0) return 0; + // assumes 16 < DB < 32 + return ((this[1]&((1<<(32-this.DB))-1))<>= this.DB; + } + if(a.t < this.t) { + c += a.s; + while(i < this.t) { + c += this[i]; + r[i++] = c&this.DM; + c >>= this.DB; + } + c += this.s; + } + else { + c += this.s; + while(i < a.t) { + c += a[i]; + r[i++] = c&this.DM; + c >>= this.DB; + } + c += a.s; + } + r.s = (c<0)?-1:0; + if(c > 0) r[i++] = c; + else if(c < -1) r[i++] = this.DV+c; + r.t = i; + r.clamp(); + } + + BigInteger.prototype.fromRadix = bnpFromRadix; + BigInteger.prototype.chunkSize = bnpChunkSize; + BigInteger.prototype.signum = bnSigNum; + BigInteger.prototype.dMultiply = bnpDMultiply; + BigInteger.prototype.dAddOffset = bnpDAddOffset; + BigInteger.prototype.toRadix = bnpToRadix; + BigInteger.prototype.intValue = bnIntValue; + BigInteger.prototype.addTo = bnpAddTo; + + //======= end jsbn ======= + + // Emscripten wrapper + var Wrapper = { + result: [0, 0], // return result stored here + add: function(xl, xh, yl, yh) { + var x = new goog.math.Long(xl, xh); + var y = new goog.math.Long(yl, yh); + var ret = x.add(y); + Wrapper.result[0] = ret.low_; + Wrapper.result[1] = ret.high_; + }, + subtract: function(xl, xh, yl, yh) { + var x = new goog.math.Long(xl, xh); + var y = new goog.math.Long(yl, yh); + var ret = x.subtract(y); + Wrapper.result[0] = ret.low_; + Wrapper.result[1] = ret.high_; + }, + multiply: function(xl, xh, yl, yh) { + var x = new goog.math.Long(xl, xh); + var y = new goog.math.Long(yl, yh); + var ret = x.multiply(y); + Wrapper.result[0] = ret.low_; + Wrapper.result[1] = ret.high_; + }, + makeTwo32: function() { + Wrapper.two32 = new BigInteger(); + Wrapper.two32.fromString('4294967296', 10); + }, + lh2bignum: function(l, h) { + var a = new BigInteger(); + a.fromString(h.toString(), 10); + var b = new BigInteger(); + a.multiplyTo(Wrapper.two32, b); + var c = new BigInteger(); + c.fromString(l.toString(), 10); + var d = new BigInteger(); + c.addTo(b, d); + return d; + }, + divide: function(xl, xh, yl, yh, unsigned) { + if (!Wrapper.two32) Wrapper.makeTwo32(); + if (!unsigned) { + var x = new goog.math.Long(xl, xh); + var y = new goog.math.Long(yl, yh); + var ret = x.div(y); + Wrapper.result[0] = ret.low_; + Wrapper.result[1] = ret.high_; + } else { + // slow precise bignum division + var x = Wrapper.lh2bignum(xl >>> 0, xh >>> 0); + var y = Wrapper.lh2bignum(yl >>> 0, yh >>> 0); + var z = new BigInteger(); + x.divRemTo(y, z, null); + var l = new BigInteger(); + var h = new BigInteger(); + z.divRemTo(Wrapper.two32, h, l); + Wrapper.result[0] = parseInt(l.toString()) | 0; + Wrapper.result[1] = parseInt(h.toString()) | 0; + } + }, + modulo: function(xl, xh, yl, yh, unsigned) { + if (!Wrapper.two32) Wrapper.makeTwo32(); + if (!unsigned) { + var x = new goog.math.Long(xl, xh); + var y = new goog.math.Long(yl, yh); + var ret = x.modulo(y); + Wrapper.result[0] = ret.low_; + Wrapper.result[1] = ret.high_; + } else { + // slow precise bignum division + var x = Wrapper.lh2bignum(xl >>> 0, xh >>> 0); + var y = Wrapper.lh2bignum(yl >>> 0, yh >>> 0); + var z = new BigInteger(); + x.divRemTo(y, null, z); + var l = new BigInteger(); + var h = new BigInteger(); + z.divRemTo(Wrapper.two32, h, l); + Wrapper.result[0] = parseInt(l.toString()) | 0; + Wrapper.result[1] = parseInt(h.toString()) | 0; + } + }, + stringify: function(l, h, unsigned) { + var ret = new goog.math.Long(l, h).toString(); + if (unsigned && ret[0] == '-') { + // unsign slowly using jsbn bignums + if (!Wrapper.two64) { + Wrapper.two64 = new BigInteger(); + Wrapper.two64.fromString('18446744073709551616', 10); + } + var bignum = new BigInteger(); + bignum.fromString(ret, 10); + ret = new BigInteger(); + Wrapper.two64.addTo(bignum, ret); + ret = ret.toString(10); + } + return ret; + } + }; + return Wrapper; +})(); + +//======= end closure i64 code ======= + + + + + function _memcpy(dest, src, num, align) { + assert(num % 1 === 0, 'memcpy given ' + num + ' bytes to copy. Problem with quantum=1 corrections perhaps?'); + if (num >= 20 && src % 2 == dest % 2) { + // This is unaligned, but quite large, and potentially alignable, so work hard to get to aligned settings + if (src % 4 == dest % 4) { + var stop = src + num; + while (src % 4) { // no need to check for stop, since we have large num + HEAP8[dest++] = HEAP8[src++]; + } + var src4 = src >> 2, dest4 = dest >> 2, stop4 = stop >> 2; + while (src4 < stop4) { + HEAP32[dest4++] = HEAP32[src4++]; + } + src = src4 << 2; + dest = dest4 << 2; + while (src < stop) { + HEAP8[dest++] = HEAP8[src++]; + } + } else { + var stop = src + num; + if (src % 2) { // no need to check for stop, since we have large num + HEAP8[dest++] = HEAP8[src++]; + } + var src2 = src >> 1, dest2 = dest >> 1, stop2 = stop >> 1; + while (src2 < stop2) { + HEAP16[dest2++] = HEAP16[src2++]; + } + src = src2 << 1; + dest = dest2 << 1; + if (src < stop) { + HEAP8[dest++] = HEAP8[src++]; + } + } + } else { + while (num--) { + HEAP8[dest++] = HEAP8[src++]; + } + } + }var _llvm_memcpy_p0i8_p0i8_i32=_memcpy; + + + function _memset(ptr, value, num, align) { + // TODO: make these settings, and in memcpy, {{'s + if (num >= 20) { + // This is unaligned, but quite large, so work hard to get to aligned settings + var stop = ptr + num; + while (ptr % 4) { // no need to check for stop, since we have large num + HEAP8[ptr++] = value; + } + if (value < 0) value += 256; // make it unsigned + var ptr4 = ptr >> 2, stop4 = stop >> 2, value4 = value | (value << 8) | (value << 16) | (value << 24); + while (ptr4 < stop4) { + HEAP32[ptr4++] = value4; + } + ptr = ptr4 << 2; + while (ptr < stop) { + HEAP8[ptr++] = value; + } + } else { + while (num--) { + HEAP8[ptr++] = value; + } + } + }var _llvm_memset_p0i8_i32=_memset; + + function _strlen(ptr) { + return String_len(ptr); + } +var _llvm_va_start; // stub for _llvm_va_start + + function _llvm_va_end() {} + + function _strcpy(pdest, psrc) { + var i = 0; + do { + HEAP8[(pdest+i)]=HEAP8[(psrc+i)]; + i ++; + } while (HEAP8[((psrc)+(i-1))] != 0); + return pdest; + } + + + + + 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}; + + function ___setErrNo(value) { + // For convenient setting and returning of errno. + if (!___setErrNo.ret) ___setErrNo.ret = allocate([0], 'i32', ALLOC_STATIC); + HEAP32[((___setErrNo.ret)>>2)]=value + return value; + } + + var _stdin=0; + + var _stdout=0; + + var _stderr=0; + + var __impure_ptr=0;var FS={currentPath:"/",nextInode:2,streams:[null],checkStreams:function () { + for (var i in FS.streams) assert(i >= 0 && i < FS.streams.length); // no keys not in dense span + for (var i = 0; i < FS.streams.length; i++) assert(typeof FS.streams[i] == 'object'); // no non-null holes in dense span + },ignorePermissions:true,joinPath:function (parts, forceRelative) { + var ret = parts[0]; + for (var i = 1; i < parts.length; i++) { + if (ret[ret.length-1] != '/') ret += '/'; + ret += parts[i]; + } + if (forceRelative && ret[0] == '/') ret = ret.substr(1); + return ret; + },absolutePath:function (relative, base) { + if (typeof relative !== 'string') return null; + if (base === undefined) base = FS.currentPath; + if (relative && relative[0] == '/') base = ''; + var full = base + '/' + relative; + var parts = full.split('/').reverse(); + var absolute = ['']; + while (parts.length) { + var part = parts.pop(); + if (part == '' || part == '.') { + // Nothing. + } else if (part == '..') { + if (absolute.length > 1) absolute.pop(); + } else { + absolute.push(part); + } + } + return absolute.length == 1 ? '/' : absolute.join('/'); + },analyzePath:function (path, dontResolveLastLink, linksVisited) { + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null + }; + path = FS.absolutePath(path); + if (path == '/') { + ret.isRoot = true; + ret.exists = ret.parentExists = true; + ret.name = '/'; + ret.path = ret.parentPath = '/'; + ret.object = ret.parentObject = FS.root; + } else if (path !== null) { + linksVisited = linksVisited || 0; + path = path.slice(1).split('/'); + var current = FS.root; + var traversed = ['']; + while (path.length) { + if (path.length == 1 && current.isFolder) { + ret.parentExists = true; + ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/'); + ret.parentObject = current; + ret.name = path[0]; + } + var target = path.shift(); + if (!current.isFolder) { + ret.error = ERRNO_CODES.ENOTDIR; + break; + } else if (!current.read) { + ret.error = ERRNO_CODES.EACCES; + break; + } else if (!current.contents.hasOwnProperty(target)) { + ret.error = ERRNO_CODES.ENOENT; + break; + } + current = current.contents[target]; + if (current.link && !(dontResolveLastLink && path.length == 0)) { + if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX. + ret.error = ERRNO_CODES.ELOOP; + break; + } + var link = FS.absolutePath(current.link, traversed.join('/')); + ret = FS.analyzePath([link].concat(path).join('/'), + dontResolveLastLink, linksVisited + 1); + return ret; + } + traversed.push(target); + if (path.length == 0) { + ret.exists = true; + ret.path = traversed.join('/'); + ret.object = current; + } + } + } + return ret; + },findObject:function (path, dontResolveLastLink) { + FS.ensureRoot(); + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + ___setErrNo(ret.error); + return null; + } + },createObject:function (parent, name, properties, canRead, canWrite) { + if (!parent) parent = '/'; + if (typeof parent === 'string') parent = FS.findObject(parent); + + if (!parent) { + ___setErrNo(ERRNO_CODES.EACCES); + throw new Error('Parent path must exist.'); + } + if (!parent.isFolder) { + ___setErrNo(ERRNO_CODES.ENOTDIR); + throw new Error('Parent must be a folder.'); + } + if (!parent.write && !FS.ignorePermissions) { + ___setErrNo(ERRNO_CODES.EACCES); + throw new Error('Parent folder must be writeable.'); + } + if (!name || name == '.' || name == '..') { + ___setErrNo(ERRNO_CODES.ENOENT); + throw new Error('Name must not be empty.'); + } + if (parent.contents.hasOwnProperty(name)) { + ___setErrNo(ERRNO_CODES.EEXIST); + throw new Error("Can't overwrite object."); + } + + parent.contents[name] = { + read: canRead === undefined ? true : canRead, + write: canWrite === undefined ? false : canWrite, + timestamp: Date.now(), + inodeNumber: FS.nextInode++ + }; + for (var key in properties) { + if (properties.hasOwnProperty(key)) { + parent.contents[name][key] = properties[key]; + } + } + + return parent.contents[name]; + },createFolder:function (parent, name, canRead, canWrite) { + var properties = {isFolder: true, isDevice: false, contents: {}}; + return FS.createObject(parent, name, properties, canRead, canWrite); + },createPath:function (parent, path, canRead, canWrite) { + var current = FS.findObject(parent); + if (current === null) throw new Error('Invalid parent.'); + path = path.split('/').reverse(); + while (path.length) { + var part = path.pop(); + if (!part) continue; + if (!current.contents.hasOwnProperty(part)) { + FS.createFolder(current, part, canRead, canWrite); + } + current = current.contents[part]; + } + return current; + },createFile:function (parent, name, properties, canRead, canWrite) { + properties.isFolder = false; + return FS.createObject(parent, name, properties, canRead, canWrite); + },createDataFile:function (parent, name, data, canRead, canWrite) { + if (typeof data === 'string') { + var dataArray = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i); + data = dataArray; + } + var properties = { + isDevice: false, + 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 + }; + return FS.createFile(parent, name, properties, canRead, canWrite); + },createLazyFile:function (parent, name, url, canRead, canWrite) { + + if (typeof XMLHttpRequest !== 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + var LazyUint8Array = function(chunkSize, length) { + this.length = length; + this.chunkSize = chunkSize; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = function(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % chunkSize; + var chunkNum = Math.floor(idx / chunkSize); + return this.getter(chunkNum)[chunkOffset]; + } + LazyUint8Array.prototype.setDataGetter = function(getter) { + this.getter = getter; + } + + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var chunkSize = 1024*1024; // Chunk size in bytes + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (function(from, to) { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }); + + var lazyArray = new LazyUint8Array(chunkSize, datalength); + lazyArray.setDataGetter(function(chunkNum) { + var start = chunkNum * lazyArray.chunkSize; + var end = (chunkNum+1) * lazyArray.chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + return FS.createFile(parent, name, properties, canRead, canWrite); + },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) { + Browser.ensureObjects(); + var fullname = FS.joinPath([parent, name], true); + function processData(byteArray) { + function finish(byteArray) { + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite); + } + if (onload) onload(); + removeRunDependency('cp ' + fullname); + } + var handled = false; + Module['preloadPlugins'].forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, function() { + if (onerror) onerror(); + removeRunDependency('cp ' + fullname); + }); + handled = true; + } + }); + if (!handled) finish(byteArray); + } + addRunDependency('cp ' + fullname); + if (typeof url == 'string') { + Browser.asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + },createLink:function (parent, name, target, canRead, canWrite) { + var properties = {isDevice: false, link: target}; + return FS.createFile(parent, name, properties, canRead, canWrite); + },createDevice:function (parent, name, input, output) { + if (!(input || output)) { + throw new Error('A device must have at least one callback defined.'); + } + var ops = {isDevice: true, input: input, output: output}; + return FS.createFile(parent, name, ops, Boolean(input), Boolean(output)); + },forceLoadFile:function (obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + var success = true; + if (typeof XMLHttpRequest !== 'undefined') { + 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."); + } else if (Module['read']) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(Module['read'](obj.url), true); + } catch (e) { + success = false; + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + if (!success) ___setErrNo(ERRNO_CODES.EIO); + return success; + },ensureRoot:function () { + if (FS.root) return; + // The main file system tree. All the contents are inside this. + FS.root = { + read: true, + write: true, + isFolder: true, + isDevice: false, + timestamp: Date.now(), + inodeNumber: 1, + contents: {} + }; + },init:function (input, output, error) { + // Make sure we initialize only once. + 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)'); + FS.init.initialized = true; + + FS.ensureRoot(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + input = input || Module['stdin']; + output = output || Module['stdout']; + error = error || Module['stderr']; + + // Default handlers. + var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true; + if (!input) { + stdinOverridden = false; + input = function() { + if (!input.cache || !input.cache.length) { + var result; + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); + if (result === null) result = String.fromCharCode(0); // cancel ==> EOF + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + } + if (!result) result = ''; + input.cache = intArrayFromString(result + '\n', true); + } + return input.cache.shift(); + }; + } + var utf8 = new Runtime.UTF8Processor(); + function simpleOutput(val) { + if (val === null || val === '\n'.charCodeAt(0)) { + output.printer(output.buffer.join('')); + output.buffer = []; + } else { + output.buffer.push(utf8.processCChar(val)); + } + } + if (!output) { + stdoutOverridden = false; + output = simpleOutput; + } + if (!output.printer) output.printer = Module['print']; + if (!output.buffer) output.buffer = []; + if (!error) { + stderrOverridden = false; + error = simpleOutput; + } + if (!error.printer) error.printer = Module['print']; + if (!error.buffer) error.buffer = []; + + // Create the temporary folder, if not already created + try { + FS.createFolder('/', 'tmp', true, true); + } catch(e) {} + + // Create the I/O devices. + var devFolder = FS.createFolder('/', 'dev', true, true); + var stdin = FS.createDevice(devFolder, 'stdin', input); + var stdout = FS.createDevice(devFolder, 'stdout', null, output); + var stderr = FS.createDevice(devFolder, 'stderr', null, error); + FS.createDevice(devFolder, 'tty', input, output); + + // Create default streams. + FS.streams[1] = { + path: '/dev/stdin', + object: stdin, + position: 0, + isRead: true, + isWrite: false, + isAppend: false, + isTerminal: !stdinOverridden, + error: false, + eof: false, + ungotten: [] + }; + FS.streams[2] = { + path: '/dev/stdout', + object: stdout, + position: 0, + isRead: false, + isWrite: true, + isAppend: false, + isTerminal: !stdoutOverridden, + error: false, + eof: false, + ungotten: [] + }; + FS.streams[3] = { + path: '/dev/stderr', + object: stderr, + position: 0, + isRead: false, + isWrite: true, + isAppend: false, + isTerminal: !stderrOverridden, + error: false, + eof: false, + ungotten: [] + }; + // Allocate these on the stack (and never free, we are called from ATINIT or earlier), to keep their locations low + _stdin = allocate([1], 'void*', ALLOC_STACK); + _stdout = allocate([2], 'void*', ALLOC_STACK); + _stderr = allocate([3], 'void*', ALLOC_STACK); + + // Other system paths + FS.createPath('/', 'dev/shm/tmp', true, true); // temp files + + // Newlib initialization + for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + 4; i++) { + FS.streams[i] = null; // Make sure to keep FS.streams dense + } + FS.streams[_stdin] = FS.streams[1]; + FS.streams[_stdout] = FS.streams[2]; + FS.streams[_stderr] = FS.streams[3]; + FS.checkStreams(); + assert(FS.streams.length < 1024); // at this early stage, we should not have a large set of file descriptors - just a few + __impure_ptr = allocate([ allocate( + [0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0], + 'void*', ALLOC_STATIC) ], 'void*', ALLOC_STATIC); + },quit:function () { + if (!FS.init.initialized) return; + // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed + if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output('\n'.charCodeAt(0)); + if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output('\n'.charCodeAt(0)); + },standardizePath:function (path) { + if (path.substr(0, 2) == './') path = path.substr(2); + return path; + },deleteFile:function (path) { + var path = FS.analyzePath(path); + if (!path.parentExists || !path.exists) { + throw 'Invalid path ' + path; + } + delete path.parentObject.contents[path.name]; + }}; + + + function _pwrite(fildes, buf, nbyte, offset) { + // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html + var stream = FS.streams[fildes]; + if (!stream || stream.object.isDevice) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isWrite) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (stream.object.isFolder) { + ___setErrNo(ERRNO_CODES.EISDIR); + return -1; + } else if (nbyte < 0 || offset < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var contents = stream.object.contents; + while (contents.length < offset) contents.push(0); + for (var i = 0; i < nbyte; i++) { + contents[offset + i] = HEAPU8[((buf)+(i))]; + } + stream.object.timestamp = Date.now(); + return i; + } + }function _write(fildes, buf, nbyte) { + // ssize_t write(int fildes, const void *buf, size_t nbyte); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html + var stream = FS.streams[fildes]; + if (!stream) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isWrite) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (nbyte < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + if (stream.object.isDevice) { + if (stream.object.output) { + for (var i = 0; i < nbyte; i++) { + try { + stream.object.output(HEAP8[((buf)+(i))]); + } catch (e) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + } + stream.object.timestamp = Date.now(); + return i; + } else { + ___setErrNo(ERRNO_CODES.ENXIO); + return -1; + } + } else { + var bytesWritten = _pwrite(fildes, buf, nbyte, stream.position); + if (bytesWritten != -1) stream.position += bytesWritten; + return bytesWritten; + } + } + }function _fwrite(ptr, size, nitems, stream) { + // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html + var bytesToWrite = nitems * size; + if (bytesToWrite == 0) return 0; + var bytesWritten = _write(stream, ptr, bytesToWrite); + if (bytesWritten == -1) { + if (FS.streams[stream]) FS.streams[stream].error = true; + return 0; + } else { + return Math.floor(bytesWritten / size); + } + } + + function __formatString(format, varargs) { + var textIndex = format; + var argIndex = 0; + function getNextArg(type) { + // NOTE: Explicitly ignoring type safety. Otherwise this fails: + // int x = 4; printf("%c\n", (char)x); + var ret; + if (type === 'double') { + ret = (tempDoubleI32[0]=HEAP32[(((varargs)+(argIndex))>>2)],tempDoubleI32[1]=HEAP32[(((varargs)+((argIndex)+(4)))>>2)],tempDoubleF64[0]); + } else if (type == 'i64') { + ret = [HEAP32[(((varargs)+(argIndex))>>2)], + HEAP32[(((varargs)+(argIndex+4))>>2)]]; + } else { + type = 'i32'; // varargs are always i32, i64, or double + ret = HEAP32[(((varargs)+(argIndex))>>2)]; + } + argIndex += Runtime.getNativeFieldSize(type); + return ret; + } + + var ret = []; + var curr, next, currArg; + while(1) { + var startTextIndex = textIndex; + curr = HEAP8[(textIndex)]; + if (curr === 0) break; + next = HEAP8[(textIndex+1)]; + if (curr == '%'.charCodeAt(0)) { + // Handle flags. + var flagAlwaysSigned = false; + var flagLeftAlign = false; + var flagAlternative = false; + var flagZeroPad = false; + flagsLoop: while (1) { + switch (next) { + case '+'.charCodeAt(0): + flagAlwaysSigned = true; + break; + case '-'.charCodeAt(0): + flagLeftAlign = true; + break; + case '#'.charCodeAt(0): + flagAlternative = true; + break; + case '0'.charCodeAt(0): + if (flagZeroPad) { + break flagsLoop; + } else { + flagZeroPad = true; + break; + } + default: + break flagsLoop; + } + textIndex++; + next = HEAP8[(textIndex+1)]; + } + + // Handle width. + var width = 0; + if (next == '*'.charCodeAt(0)) { + width = getNextArg('i32'); + textIndex++; + next = HEAP8[(textIndex+1)]; + } else { + while (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) { + width = width * 10 + (next - '0'.charCodeAt(0)); + textIndex++; + next = HEAP8[(textIndex+1)]; + } + } + + // Handle precision. + var precisionSet = false; + if (next == '.'.charCodeAt(0)) { + var precision = 0; + precisionSet = true; + textIndex++; + next = HEAP8[(textIndex+1)]; + if (next == '*'.charCodeAt(0)) { + precision = getNextArg('i32'); + textIndex++; + } else { + while(1) { + var precisionChr = HEAP8[(textIndex+1)]; + if (precisionChr < '0'.charCodeAt(0) || + precisionChr > '9'.charCodeAt(0)) break; + precision = precision * 10 + (precisionChr - '0'.charCodeAt(0)); + textIndex++; + } + } + next = HEAP8[(textIndex+1)]; + } else { + var precision = 6; // Standard default. + } + + // Handle integer sizes. WARNING: These assume a 32-bit architecture! + var argSize; + switch (String.fromCharCode(next)) { + case 'h': + var nextNext = HEAP8[(textIndex+2)]; + if (nextNext == 'h'.charCodeAt(0)) { + textIndex++; + argSize = 1; // char (actually i32 in varargs) + } else { + argSize = 2; // short (actually i32 in varargs) + } + break; + case 'l': + var nextNext = HEAP8[(textIndex+2)]; + if (nextNext == 'l'.charCodeAt(0)) { + textIndex++; + argSize = 8; // long long + } else { + argSize = 4; // long + } + break; + case 'L': // long long + case 'q': // int64_t + case 'j': // intmax_t + argSize = 8; + break; + case 'z': // size_t + case 't': // ptrdiff_t + case 'I': // signed ptrdiff_t or unsigned size_t + argSize = 4; + break; + default: + argSize = null; + } + if (argSize) textIndex++; + next = HEAP8[(textIndex+1)]; + + // Handle type specifier. + if (['d', 'i', 'u', 'o', 'x', 'X', 'p'].indexOf(String.fromCharCode(next)) != -1) { + // Integer. + var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0); + argSize = argSize || 4; + var currArg = getNextArg('i' + (argSize * 8)); + var origArg = currArg; + var argText; + // Flatten i64-1 [low, high] into a (slightly rounded) double + if (argSize == 8) { + currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0)); + } + // Truncate to requested size. + if (argSize <= 4) { + var limit = Math.pow(256, argSize) - 1; + currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8); + } + // Format the number. + var currAbsArg = Math.abs(currArg); + var prefix = ''; + if (next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0)) { + if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1]); else + argText = reSign(currArg, 8 * argSize, 1).toString(10); + } else if (next == 'u'.charCodeAt(0)) { + if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else + argText = unSign(currArg, 8 * argSize, 1).toString(10); + currArg = Math.abs(currArg); + } else if (next == 'o'.charCodeAt(0)) { + argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8); + } else if (next == 'x'.charCodeAt(0) || next == 'X'.charCodeAt(0)) { + prefix = flagAlternative ? '0x' : ''; + if (currArg < 0) { + // Represent negative numbers in hex as 2's complement. + currArg = -currArg; + argText = (currAbsArg - 1).toString(16); + var buffer = []; + for (var i = 0; i < argText.length; i++) { + buffer.push((0xF - parseInt(argText[i], 16)).toString(16)); + } + argText = buffer.join(''); + while (argText.length < argSize * 2) argText = 'f' + argText; + } else { + argText = currAbsArg.toString(16); + } + if (next == 'X'.charCodeAt(0)) { + prefix = prefix.toUpperCase(); + argText = argText.toUpperCase(); + } + } else if (next == 'p'.charCodeAt(0)) { + if (currAbsArg === 0) { + argText = '(nil)'; + } else { + prefix = '0x'; + argText = currAbsArg.toString(16); + } + } + if (precisionSet) { + while (argText.length < precision) { + argText = '0' + argText; + } + } + + // Add sign if needed + if (flagAlwaysSigned) { + if (currArg < 0) { + prefix = '-' + prefix; + } else { + prefix = '+' + prefix; + } + } + + // Add padding. + while (prefix.length + argText.length < width) { + if (flagLeftAlign) { + argText += ' '; + } else { + if (flagZeroPad) { + argText = '0' + argText; + } else { + prefix = ' ' + prefix; + } + } + } + + // Insert the result into the buffer. + argText = prefix + argText; + argText.split('').forEach(function(chr) { + ret.push(chr.charCodeAt(0)); + }); + } else if (['f', 'F', 'e', 'E', 'g', 'G'].indexOf(String.fromCharCode(next)) != -1) { + // Float. + var currArg = getNextArg('double'); + var argText; + + if (isNaN(currArg)) { + argText = 'nan'; + flagZeroPad = false; + } else if (!isFinite(currArg)) { + argText = (currArg < 0 ? '-' : '') + 'inf'; + flagZeroPad = false; + } else { + var isGeneral = false; + var effectivePrecision = Math.min(precision, 20); + + // Convert g/G to f/F or e/E, as per: + // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html + if (next == 'g'.charCodeAt(0) || next == 'G'.charCodeAt(0)) { + isGeneral = true; + precision = precision || 1; + var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10); + if (precision > exponent && exponent >= -4) { + next = ((next == 'g'.charCodeAt(0)) ? 'f' : 'F').charCodeAt(0); + precision -= exponent + 1; + } else { + next = ((next == 'g'.charCodeAt(0)) ? 'e' : 'E').charCodeAt(0); + precision--; + } + effectivePrecision = Math.min(precision, 20); + } + + if (next == 'e'.charCodeAt(0) || next == 'E'.charCodeAt(0)) { + argText = currArg.toExponential(effectivePrecision); + // Make sure the exponent has at least 2 digits. + if (/[eE][-+]\d$/.test(argText)) { + argText = argText.slice(0, -1) + '0' + argText.slice(-1); + } + } else if (next == 'f'.charCodeAt(0) || next == 'F'.charCodeAt(0)) { + argText = currArg.toFixed(effectivePrecision); + } + + var parts = argText.split('e'); + if (isGeneral && !flagAlternative) { + // Discard trailing zeros and periods. + while (parts[0].length > 1 && parts[0].indexOf('.') != -1 && + (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) { + parts[0] = parts[0].slice(0, -1); + } + } else { + // Make sure we have a period in alternative mode. + if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.'; + // Zero pad until required precision. + while (precision > effectivePrecision++) parts[0] += '0'; + } + argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : ''); + + // Capitalize 'E' if needed. + if (next == 'E'.charCodeAt(0)) argText = argText.toUpperCase(); + + // Add sign. + if (flagAlwaysSigned && currArg >= 0) { + argText = '+' + argText; + } + } + + // Add padding. + while (argText.length < width) { + if (flagLeftAlign) { + argText += ' '; + } else { + if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) { + argText = argText[0] + '0' + argText.slice(1); + } else { + argText = (flagZeroPad ? '0' : ' ') + argText; + } + } + } + + // Adjust case. + if (next < 'a'.charCodeAt(0)) argText = argText.toUpperCase(); + + // Insert the result into the buffer. + argText.split('').forEach(function(chr) { + ret.push(chr.charCodeAt(0)); + }); + } else if (next == 's'.charCodeAt(0)) { + // String. + var arg = getNextArg('i8*') || nullString; + var argLength = String_len(arg); + if (precisionSet) argLength = Math.min(argLength, precision); + if (!flagLeftAlign) { + while (argLength < width--) { + ret.push(' '.charCodeAt(0)); + } + } + for (var i = 0; i < argLength; i++) { + ret.push(HEAPU8[(arg++)]); + } + if (flagLeftAlign) { + while (argLength < width--) { + ret.push(' '.charCodeAt(0)); + } + } + } else if (next == 'c'.charCodeAt(0)) { + // Character. + if (flagLeftAlign) ret.push(getNextArg('i8')); + while (--width > 0) { + ret.push(' '.charCodeAt(0)); + } + if (!flagLeftAlign) ret.push(getNextArg('i8')); + } else if (next == 'n'.charCodeAt(0)) { + // Write the length written so far to the next parameter. + var ptr = getNextArg('i32*'); + HEAP32[((ptr)>>2)]=ret.length + } else if (next == '%'.charCodeAt(0)) { + // Literal percent sign. + ret.push(curr); + } else { + // Unknown specifiers remain untouched. + for (var i = startTextIndex; i < textIndex + 2; i++) { + ret.push(HEAP8[(i)]); + } + } + textIndex += 2; + // TODO: Support a/A (hex float) and m (last error) specifiers. + // TODO: Support %1${specifier} for arg selection. + } else { + ret.push(curr); + textIndex += 1; + } + } + return ret; + }function _fprintf(stream, format, varargs) { + // int fprintf(FILE *restrict stream, const char *restrict format, ...); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html + var result = __formatString(format, varargs); + var stack = Runtime.stackSave(); + var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream); + Runtime.stackRestore(stack); + return ret; + } + + function _abort() { + ABORT = true; + throw 'abort() at ' + (new Error().stack); + } + + + function _strncmp(px, py, n) { + var i = 0; + while (i < n) { + var x = HEAPU8[((px)+(i))]; + var y = HEAPU8[((py)+(i))]; + if (x == y && x == 0) return 0; + if (x == 0) return -1; + if (y == 0) return 1; + if (x == y) { + i ++; + continue; + } else { + return x > y ? 1 : -1; + } + } + return 0; + }function _strcmp(px, py) { + return _strncmp(px, py, TOTAL_MEMORY); + } + + + + function _close(fildes) { + // int close(int fildes); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html + if (FS.streams[fildes]) { + if (FS.streams[fildes].currentEntry) { + _free(FS.streams[fildes].currentEntry); + } + FS.streams[fildes] = null; + return 0; + } else { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } + } + + function _fsync(fildes) { + // int fsync(int fildes); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html + if (FS.streams[fildes]) { + // We write directly to the file system, so there's nothing to do here. + return 0; + } else { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } + }function _fclose(stream) { + // int fclose(FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html + _fsync(stream); + return _close(stream); + } + + var _vfprintf=_fprintf; + + function _printf(format, varargs) { + // int printf(const char *restrict format, ...); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html + var stdout = HEAP32[((_stdout)>>2)]; + return _fprintf(stdout, format, varargs); + } + + function _strncat(pdest, psrc, num) { + var len = _strlen(pdest); + var i = 0; + while(1) { + HEAP8[(pdest+len+i)]=HEAP8[(psrc+i)]; + if (HEAP8[((pdest)+(len+i))] == 0) break; + i ++; + if (i == num) { + HEAP8[((pdest)+(len+i))]=0 + break; + } + } + return pdest; + } + + function _isspace(chr) { + return chr in { 32: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0 }; + } + + function _isdigit(chr) { + return chr >= '0'.charCodeAt(0) && chr <= '9'.charCodeAt(0); + } + + + + function __isFloat(text) { + return !!(/^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?$/.exec(text)); + }function __scanString(format, get, unget, varargs) { + if (!__scanString.whiteSpace) { + __scanString.whiteSpace = {}; + __scanString.whiteSpace[' '.charCodeAt(0)] = 1; + __scanString.whiteSpace['\t'.charCodeAt(0)] = 1; + __scanString.whiteSpace['\n'.charCodeAt(0)] = 1; + __scanString.whiteSpace[' '] = 1; + __scanString.whiteSpace['\t'] = 1; + __scanString.whiteSpace['\n'] = 1; + } + // Supports %x, %4x, %d.%d, %lld, %s, %f, %lf. + // TODO: Support all format specifiers. + format = Pointer_stringify(format); + var soFar = 0; + if (format.indexOf('%n') >= 0) { + // need to track soFar + var _get = get; + get = function() { + soFar++; + return _get(); + } + var _unget = unget; + unget = function() { + soFar--; + return _unget(); + } + } + var formatIndex = 0; + var argsi = 0; + var fields = 0; + var argIndex = 0; + var next; + + next = 1; + mainLoop: + for (var formatIndex = 0; formatIndex < format.length; formatIndex++) { + // remove whitespace + while (1) { + next = get(); + if (next == 0) return fields; + if (!(next in __scanString.whiteSpace)) break; + } + unget(next); + + if (next <= 0) return fields; + var next = get(); + if (next <= 0) return fields; // End of input. + + if (format[formatIndex] === '%') { + formatIndex++; + var maxSpecifierStart = formatIndex; + while (format[formatIndex].charCodeAt(0) >= '0'.charCodeAt(0) && + format[formatIndex].charCodeAt(0) <= '9'.charCodeAt(0)) { + formatIndex++; + } + var max_; + if (formatIndex != maxSpecifierStart) { + max_ = parseInt(format.slice(maxSpecifierStart, formatIndex), 10); + } + var long_ = false; + var half = false; + var longLong = false; + if (format[formatIndex] == 'l') { + long_ = true; + formatIndex++; + if(format[formatIndex] == 'l') { + longLong = true; + formatIndex++; + } + } else if (format[formatIndex] == 'h') { + half = true; + formatIndex++; + } + var type = format[formatIndex]; + formatIndex++; + var curr = 0; + var buffer = []; + // Read characters according to the format. floats are trickier, they may be in an unfloat state in the middle, then be a valid float later + if (type == 'f') { + var last = 0; + while (next > 0) { + buffer.push(String.fromCharCode(next)); + if (__isFloat(buffer.join(''))) { + last = buffer.length; + } + next = get(); + } + unget(next); + while (buffer.length > last) { + unget(buffer.pop().charCodeAt(0)); + } + next = get(); + } else if (type != 'n') { + var first = true; + while ((curr < max_ || isNaN(max_)) && next > 0) { + if (!(next in __scanString.whiteSpace) && // stop on whitespace + (type == 's' || + ((type === 'd' || type == 'u' || type == 'i') && ((next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) || + (first && next == '-'.charCodeAt(0)))) || + (type === 'x' && (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0) || + next >= 'a'.charCodeAt(0) && next <= 'f'.charCodeAt(0) || + next >= 'A'.charCodeAt(0) && next <= 'F'.charCodeAt(0)))) && + (formatIndex >= format.length || next !== format[formatIndex].charCodeAt(0))) { // Stop when we read something that is coming up + buffer.push(String.fromCharCode(next)); + next = get(); + curr++; + } else { + break; + } + first = false; + } + } + if (buffer.length === 0 && type != 'n') return 0; // Failure. + var text = buffer.join(''); + var argPtr = HEAP32[(((varargs)+(argIndex))>>2)]; + argIndex += Runtime.getNativeFieldSize('void*'); + switch (type) { + case 'd': case 'u': case 'i': + if (half) { + HEAP16[((argPtr)>>1)]=parseInt(text, 10); + } else if(longLong) { + (tempI64 = [parseInt(text, 10)>>>0,Math.min(Math.floor((parseInt(text, 10))/4294967296), 4294967295)],HEAP32[((argPtr)>>2)]=tempI64[0],HEAP32[(((argPtr)+(4))>>2)]=tempI64[1]); + } else { + HEAP32[((argPtr)>>2)]=parseInt(text, 10); + } + break; + case 'x': + HEAP32[((argPtr)>>2)]=parseInt(text, 16) + break; + case 'f': + if (long_) { + (tempDoubleF64[0]=parseFloat(text),HEAP32[((argPtr)>>2)]=tempDoubleI32[0],HEAP32[(((argPtr)+(4))>>2)]=tempDoubleI32[1]) + } else { + HEAPF32[((argPtr)>>2)]=parseFloat(text) + } + break; + case 's': + var array = intArrayFromString(text); + for (var j = 0; j < array.length; j++) { + HEAP8[((argPtr)+(j))]=array[j] + } + break; + case 'n': + HEAP32[((argPtr)>>2)]=soFar-1 + break; + } + if (type != 'n') fields++; + if (next <= 0) break mainLoop; // End of input. + } else if (format[formatIndex] in __scanString.whiteSpace) { + while (next in __scanString.whiteSpace) { + next = get(); + if (next <= 0) break mainLoop; // End of input. + } + unget(next); + } else { + // Not a specifier. + if (format[formatIndex].charCodeAt(0) !== next) { + unget(next); + break mainLoop; + } + } + } + // 'n' is special in that it needs no input. so it can be at the end, even with nothing left to read + if (format[formatIndex-1] == '%' && format[formatIndex] == 'n') { + var argPtr = HEAP32[(((varargs)+(argIndex))>>2)]; + HEAP32[((argPtr)>>2)]=soFar-1 + } + return fields; + }function _sscanf(s, format, varargs) { + // int sscanf(const char *restrict s, const char *restrict format, ... ); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html + var index = 0; + var get = function() { return HEAP8[((s)+(index++))]; }; + var unget = function() { index--; }; + return __scanString(format, get, unget, varargs); + } + + function _strtod(str, endptr) { + var origin = str; + + // Skip space. + while (_isspace(HEAP8[(str)])) str++; + + // Check for a plus/minus sign. + var multiplier = 1; + if (HEAP8[(str)] == '-'.charCodeAt(0)) { + multiplier = -1; + str++; + } else if (HEAP8[(str)] == '+'.charCodeAt(0)) { + str++; + } + + var chr; + var ret = 0; + + // Get whole part. + var whole = false; + while(1) { + chr = HEAP8[(str)]; + if (!_isdigit(chr)) break; + whole = true; + ret = ret*10 + chr - '0'.charCodeAt(0); + str++; + } + + // Get fractional part. + var fraction = false; + if (HEAP8[(str)] == '.'.charCodeAt(0)) { + str++; + var mul = 1/10; + while(1) { + chr = HEAP8[(str)]; + if (!_isdigit(chr)) break; + fraction = true; + ret += mul*(chr - '0'.charCodeAt(0)); + mul /= 10; + str++; + } + } + + if (!whole && !fraction) { + if (endptr) { + HEAP32[((endptr)>>2)]=origin + } + return 0; + } + + // Get exponent part. + chr = HEAP8[(str)]; + if (chr == 'e'.charCodeAt(0) || chr == 'E'.charCodeAt(0)) { + str++; + var exponent = 0; + var expNegative = false; + chr = HEAP8[(str)]; + if (chr == '-'.charCodeAt(0)) { + expNegative = true; + str++; + } else if (chr == '+'.charCodeAt(0)) { + str++; + } + chr = HEAP8[(str)]; + while(1) { + if (!_isdigit(chr)) break; + exponent = exponent*10 + chr - '0'.charCodeAt(0); + str++; + chr = HEAP8[(str)]; + } + if (expNegative) exponent = -exponent; + ret *= Math.pow(10, exponent); + } + + // Set end pointer. + if (endptr) { + HEAP32[((endptr)>>2)]=str + } + + return ret * multiplier; + } + + + function __parseInt(str, endptr, base, min, max, bits, unsign) { + // Skip space. + while (_isspace(HEAP8[(str)])) str++; + + // Check for a plus/minus sign. + var multiplier = 1; + if (HEAP8[(str)] == '-'.charCodeAt(0)) { + multiplier = -1; + str++; + } else if (HEAP8[(str)] == '+'.charCodeAt(0)) { + str++; + } + + // Find base. + var finalBase = base; + if (!finalBase) { + if (HEAP8[(str)] == '0'.charCodeAt(0)) { + if (HEAP8[(str+1)] == 'x'.charCodeAt(0) || + HEAP8[(str+1)] == 'X'.charCodeAt(0)) { + finalBase = 16; + str += 2; + } else { + finalBase = 8; + str++; + } + } + } + if (!finalBase) finalBase = 10; + + // Get digits. + var chr; + var ret = 0; + while ((chr = HEAP8[(str)]) != 0) { + var digit = parseInt(String.fromCharCode(chr), finalBase); + if (isNaN(digit)) { + break; + } else { + ret = ret * finalBase + digit; + str++; + } + } + + // Apply sign. + ret *= multiplier; + + // Set end pointer. + if (endptr) { + HEAP32[((endptr)>>2)]=str + } + + // Unsign if needed. + if (unsign) { + if (Math.abs(ret) > max) { + ret = max; + ___setErrNo(ERRNO_CODES.ERANGE); + } else { + ret = unSign(ret, bits); + } + } + + // Validate range. + if (ret > max || ret < min) { + ret = ret > max ? max : min; + ___setErrNo(ERRNO_CODES.ERANGE); + } + + if (bits == 64) { + ret = [ret>>>0,Math.min(Math.floor((ret)/4294967296), 4294967295)]; + } + + return ret; + }function _strtol(str, endptr, base) { + return __parseInt(str, endptr, base, -2147483648, 2147483647, 32); // LONG_MIN, LONG_MAX. + } + + function _isalpha(chr) { + return (chr >= 'a'.charCodeAt(0) && chr <= 'z'.charCodeAt(0)) || + (chr >= 'A'.charCodeAt(0) && chr <= 'Z'.charCodeAt(0)); + } + + + + function _pread(fildes, buf, nbyte, offset) { + // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html + var stream = FS.streams[fildes]; + if (!stream || stream.object.isDevice) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isRead) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (stream.object.isFolder) { + ___setErrNo(ERRNO_CODES.EISDIR); + return -1; + } else if (nbyte < 0 || offset < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var bytesRead = 0; + while (stream.ungotten.length && nbyte > 0) { + HEAP8[(buf++)]=stream.ungotten.pop() + nbyte--; + bytesRead++; + } + var contents = stream.object.contents; + var size = Math.min(contents.length - offset, nbyte); + if (contents.subarray || contents.slice) { // typed array or normal array + for (var i = 0; i < size; i++) { + HEAP8[((buf)+(i))]=contents[offset + i] + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + HEAP8[((buf)+(i))]=contents.get(offset + i) + } + } + bytesRead += size; + return bytesRead; + } + }function _read(fildes, buf, nbyte) { + // ssize_t read(int fildes, void *buf, size_t nbyte); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html + var stream = FS.streams[fildes]; + if (!stream) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isRead) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (nbyte < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var bytesRead; + if (stream.object.isDevice) { + if (stream.object.input) { + bytesRead = 0; + while (stream.ungotten.length && nbyte > 0) { + HEAP8[(buf++)]=stream.ungotten.pop() + nbyte--; + bytesRead++; + } + for (var i = 0; i < nbyte; i++) { + try { + var result = stream.object.input(); + } catch (e) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + if (result === null || result === undefined) break; + bytesRead++; + HEAP8[((buf)+(i))]=result + } + return bytesRead; + } else { + ___setErrNo(ERRNO_CODES.ENXIO); + return -1; + } + } else { + var ungotSize = stream.ungotten.length; + bytesRead = _pread(fildes, buf, nbyte, stream.position); + if (bytesRead != -1) { + stream.position += (stream.ungotten.length - ungotSize) + bytesRead; + } + return bytesRead; + } + } + }function _fgetc(stream) { + // int fgetc(FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fgetc.html + if (!FS.streams[stream]) return -1; + var streamObj = FS.streams[stream]; + if (streamObj.eof || streamObj.error) return -1; + var ret = _read(stream, _fgetc.ret, 1); + if (ret == 0) { + streamObj.eof = true; + return -1; + } else if (ret == -1) { + streamObj.error = true; + return -1; + } else { + return HEAPU8[(_fgetc.ret)]; + } + } + + + function __exit(status) { + // void _exit(int status); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html + + + exitRuntime(); + ABORT = true; + + throw 'exit(' + status + ') called, at ' + new Error().stack; + }function _exit(status) { + __exit(status); + } + + + function _atoi(ptr) { + return _strtol(ptr, null, 10); + } + + function _memcmp(p1, p2, num) { + for (var i = 0; i < num; i++) { + var v1 = HEAPU8[((p1)+(i))]; + var v2 = HEAPU8[((p2)+(i))]; + if (v1 != v2) return v1 > v2 ? 1 : -1; + } + return 0; + } + + function _isupper(chr) { + return chr >= 'A'.charCodeAt(0) && chr <= 'Z'.charCodeAt(0); + } + + function _fputc(c, stream) { + // int fputc(int c, FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html + var chr = unSign(c & 0xFF); + HEAP8[(_fputc.ret)]=chr + var ret = _write(stream, _fputc.ret, 1); + if (ret == -1) { + if (FS.streams[stream]) FS.streams[stream].error = true; + return -1; + } else { + return chr; + } + } + + function _fputs(s, stream) { + // int fputs(const char *restrict s, FILE *restrict stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html + return _write(stream, s, _strlen(s)); + } + + var _getc=_fgetc; + + function _ferror(stream) { + // int ferror(FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/ferror.html + return Number(FS.streams[stream] && FS.streams[stream].error); + } + + + + var ___dirent_struct_layout=null;function _open(path, oflag, varargs) { + // int open(const char *path, int oflag, ...); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/open.html + // NOTE: This implementation tries to mimic glibc rather that strictly + // following the POSIX standard. + + var mode = HEAP32[((varargs)>>2)]; + + // Simplify flags. + var accessMode = oflag & 3; + var isWrite = accessMode != 0; + var isRead = accessMode != 1; + var isCreate = Boolean(oflag & 512); + var isExistCheck = Boolean(oflag & 2048); + var isTruncate = Boolean(oflag & 1024); + var isAppend = Boolean(oflag & 8); + + // Verify path. + var origPath = path; + path = FS.analyzePath(Pointer_stringify(path)); + if (!path.parentExists) { + ___setErrNo(path.error); + return -1; + } + var target = path.object || null; + var finalPath; + + // Verify the file exists, create if needed and allowed. + if (target) { + if (isCreate && isExistCheck) { + ___setErrNo(ERRNO_CODES.EEXIST); + return -1; + } + if ((isWrite || isCreate || isTruncate) && target.isFolder) { + ___setErrNo(ERRNO_CODES.EISDIR); + return -1; + } + if (isRead && !target.read || isWrite && !target.write) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } + if (isTruncate && !target.isDevice) { + target.contents = []; + } else { + if (!FS.forceLoadFile(target)) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + } + finalPath = path.path; + } else { + if (!isCreate) { + ___setErrNo(ERRNO_CODES.ENOENT); + return -1; + } + if (!path.parentObject.write) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } + target = FS.createDataFile(path.parentObject, path.name, [], + mode & 0x100, mode & 0x80); // S_IRUSR, S_IWUSR. + finalPath = path.parentPath + '/' + path.name; + } + // Actually create an open stream. + var id = FS.streams.length; // Keep dense + if (target.isFolder) { + var entryBuffer = 0; + if (___dirent_struct_layout) { + entryBuffer = _malloc(___dirent_struct_layout.__size__); + } + var contents = []; + for (var key in target.contents) contents.push(key); + FS.streams[id] = { + path: finalPath, + object: target, + // An index into contents. Special values: -2 is ".", -1 is "..". + position: -2, + isRead: true, + isWrite: false, + isAppend: false, + error: false, + eof: false, + ungotten: [], + // Folder-specific properties: + // Remember the contents at the time of opening in an array, so we can + // seek between them relying on a single order. + contents: contents, + // Each stream has its own area for readdir() returns. + currentEntry: entryBuffer + }; + } else { + FS.streams[id] = { + path: finalPath, + object: target, + position: 0, + isRead: isRead, + isWrite: isWrite, + isAppend: isAppend, + error: false, + eof: false, + ungotten: [] + }; + } + FS.checkStreams(); + return id; + }function _fopen(filename, mode) { + // FILE *fopen(const char *restrict filename, const char *restrict mode); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fopen.html + var flags; + mode = Pointer_stringify(mode); + if (mode[0] == 'r') { + if (mode.indexOf('+') != -1) { + flags = 2; + } else { + flags = 0; + } + } else if (mode[0] == 'w') { + if (mode.indexOf('+') != -1) { + flags = 2; + } else { + flags = 1; + } + flags |= 512; + flags |= 1024; + } else if (mode[0] == 'a') { + if (mode.indexOf('+') != -1) { + flags = 2; + } else { + flags = 1; + } + flags |= 512; + flags |= 8; + } else { + ___setErrNo(ERRNO_CODES.EINVAL); + return 0; + } + var ret = _open(filename, flags, allocate([0x1FF, 0, 0, 0], 'i32', ALLOC_STACK)); // All creation permissions. + return (ret == -1) ? 0 : ret; + } +var _llvm_dbg_declare; // stub for _llvm_dbg_declare +var _llvm_expect_i32; // stub for _llvm_expect_i32 + + function _sysconf(name) { + // long sysconf(int name); + // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html + switch(name) { + case 8: return PAGE_SIZE; + case 54: + case 56: + case 21: + case 61: + case 63: + case 22: + case 67: + case 23: + case 24: + case 25: + case 26: + case 27: + case 69: + case 28: + case 101: + case 70: + case 71: + case 29: + case 30: + case 199: + case 75: + case 76: + case 32: + case 43: + case 44: + case 80: + case 46: + case 47: + case 45: + case 48: + case 49: + case 42: + case 82: + case 33: + case 7: + case 108: + case 109: + case 107: + case 112: + case 119: + case 121: + return 200809; + case 13: + case 104: + case 94: + case 95: + case 34: + case 35: + case 77: + case 81: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 94: + case 95: + case 110: + case 111: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 120: + case 40: + case 16: + case 79: + case 19: + return -1; + case 92: + case 93: + case 5: + case 72: + case 6: + case 74: + case 92: + case 93: + case 96: + case 97: + case 98: + case 99: + case 102: + case 103: + case 105: + return 1; + case 38: + case 66: + case 50: + case 51: + case 4: + return 1024; + case 15: + case 64: + case 41: + return 32; + case 55: + case 37: + case 17: + return 2147483647; + case 18: + case 1: + return 47839; + case 59: + case 57: + return 99; + case 68: + case 58: + return 2048; + case 0: return 2097152; + case 3: return 65536; + case 14: return 32768; + case 73: return 32767; + case 39: return 16384; + case 60: return 1000; + case 106: return 700; + case 52: return 256; + case 62: return 255; + case 2: return 100; + case 65: return 64; + case 36: return 20; + case 100: return 16; + case 20: return 6; + case 53: return 4; + } + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } + + function _time(ptr) { + var ret = Math.floor(Date.now()/1000); + if (ptr) { + HEAP32[((ptr)>>2)]=ret + } + return ret; + } + + + function ___errno_location() { + return ___setErrNo.ret; + }var ___errno=___errno_location; + + function _sbrk(bytes) { + // Implement a Linux-like 'memory area' for our 'process'. + // Changes the size of the memory area by |bytes|; returns the + // address of the previous top ('break') of the memory area + + // We need to make sure no one else allocates unfreeable memory! + // We must control this entirely. So we don't even need to do + // unfreeable allocations - the HEAP is ours, from STATICTOP up. + // TODO: We could in theory slice off the top of the HEAP when + // sbrk gets a negative increment in |bytes|... + var self = _sbrk; + if (!self.called) { + STATICTOP = alignMemoryPage(STATICTOP); // make sure we start out aligned + self.called = true; + _sbrk.DYNAMIC_START = STATICTOP; + } + var ret = STATICTOP; + if (bytes != 0) Runtime.staticAlloc(bytes); + return ret; // Previous break location. + } + + + + + + var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false,queue:[],pause:function () { + Browser.mainLoop.shouldPause = true; + },resume:function () { + if (Browser.mainLoop.paused) { + Browser.mainLoop.paused = false; + Browser.mainLoop.scheduler(); + } + Browser.mainLoop.shouldPause = false; + },updateStatus:function () { + if (Module['setStatus']) { + var message = Module['statusMessage'] || 'Please wait...'; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')'); + } else { + Module['setStatus'](message); + } + } else { + Module['setStatus'](''); + } + } + }},pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],ensureObjects:function () { + if (Browser.ensured) return; + Browser.ensured = true; + try { + new Blob(); + Browser.hasBlobConstructor = true; + } catch(e) { + Browser.hasBlobConstructor = false; + console.log("warning: no blob constructor, cannot create blobs with mimetypes"); + } + Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null)); + Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : console.log("warning: cannot create object URLs"); + + // Support for plugins that can process preloaded files. You can add more of these to + // your app by creating and appending to Module.preloadPlugins. + // + // Each plugin is asked if it can handle a file based on the file's name. If it can, + // it is given the file's raw data. When it is done, it calls a callback with the file's + // (possibly modified) data. For example, a plugin might decompress a file, or it + // might create some side data structure for use later (like an Image element, etc.). + + function getMimetype(name) { + return { + 'jpg': 'image/jpeg', + 'png': 'image/png', + 'bmp': 'image/bmp', + 'ogg': 'audio/ogg', + 'wav': 'audio/wav', + 'mp3': 'audio/mpeg' + }[name.substr(-3)]; + return ret; + } + + if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; + + var imagePlugin = {}; + imagePlugin['canHandle'] = function(name) { + return name.substr(-4) in { '.jpg': 1, '.png': 1, '.bmp': 1 }; + }; + imagePlugin['handle'] = function(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([byteArray], { type: getMimetype(name) }); + } catch(e) { + Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder'); + } + } + if (!b) { + var bb = new Browser.BlobBuilder(); + bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range + b = bb.getBlob(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == 'string', 'createObjectURL must return a url as a string'); + var img = new Image(); + img.onload = function() { + assert(img.complete, 'Image ' + name + ' could not be decoded'); + var canvas = document.createElement('canvas'); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext('2d'); + ctx.drawImage(img, 0, 0); + Module["preloadedImages"][name] = canvas; + Browser.URLObject.revokeObjectURL(url); + if (onload) onload(byteArray); + }; + img.onerror = function(event) { + console.log('Image ' + url + ' could not be decoded'); + if (onerror) onerror(); + }; + img.src = url; + }; + Module['preloadPlugins'].push(imagePlugin); + + var audioPlugin = {}; + audioPlugin['canHandle'] = function(name) { + return name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 }; + }; + audioPlugin['handle'] = function(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) return; + done = true; + Module["preloadedAudios"][name] = audio; + if (onload) onload(byteArray); + } + function fail() { + if (done) return; + done = true; + Module["preloadedAudios"][name] = new Audio(); // empty shim + if (onerror) onerror(); + } + if (Browser.hasBlobConstructor) { + try { + var b = new Blob([byteArray], { type: getMimetype(name) }); + } catch(e) { + return fail(); + } + var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this! + assert(typeof url == 'string', 'createObjectURL must return a url as a string'); + var audio = new Audio(); + audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926 + audio.onerror = function(event) { + if (done) return; + console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach'); + function encode64(data) { + var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + var PAD = '='; + var ret = ''; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = (leftchar << 8) | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = (leftchar >> (leftbits-6)) & 0x3f; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar&3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar&0xf) << 2]; + ret += PAD; + } + return ret; + } + audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray); + finish(audio); // we don't wait for confirmation this worked - but it's worth trying + }; + audio.src = url; + // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror + setTimeout(function() { + finish(audio); // try to use it even though it is not necessarily ready to play + }, 10000); + } else { + return fail(); + } + }; + Module['preloadPlugins'].push(audioPlugin); + },createContext:function (canvas, useWebGL, setInModule) { + try { + var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d'); + if (!ctx) throw ':('; + } catch (e) { + Module.print('Could not create canvas - ' + e); + return null; + } + if (useWebGL) { + // Set the background of the WebGL canvas to black + canvas.style.backgroundColor = "black"; + + // Warn on context loss + canvas.addEventListener('webglcontextlost', function(event) { + alert('WebGL context lost. You will need to reload the page.'); + }, false); + } + if (setInModule) { + Module.ctx = ctx; + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() }); + } + return ctx; + },requestFullScreen:function () { + var canvas = Module['canvas']; + function fullScreenChange() { + var isFullScreen = false; + if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] || + document['mozFullScreenElement'] || document['mozFullscreenElement'] || + document['fullScreenElement'] || document['fullscreenElement']) === canvas) { + canvas.requestPointerLock = canvas['requestPointerLock'] || + canvas['mozRequestPointerLock'] || + canvas['webkitRequestPointerLock']; + canvas.requestPointerLock(); + isFullScreen = true; + } + if (Module['onFullScreen']) Module['onFullScreen'](isFullScreen); + } + + document.addEventListener('fullscreenchange', fullScreenChange, false); + document.addEventListener('mozfullscreenchange', fullScreenChange, false); + document.addEventListener('webkitfullscreenchange', fullScreenChange, false); + + function pointerLockChange() { + Browser.pointerLock = document['pointerLockElement'] === canvas || + document['mozPointerLockElement'] === canvas || + document['webkitPointerLockElement'] === canvas; + } + + document.addEventListener('pointerlockchange', pointerLockChange, false); + document.addEventListener('mozpointerlockchange', pointerLockChange, false); + document.addEventListener('webkitpointerlockchange', pointerLockChange, false); + + canvas.requestFullScreen = canvas['requestFullScreen'] || + canvas['mozRequestFullScreen'] || + (canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null); + canvas.requestFullScreen(); + },requestAnimationFrame:function (func) { + if (!window.requestAnimationFrame) { + window.requestAnimationFrame = window['requestAnimationFrame'] || + window['mozRequestAnimationFrame'] || + window['webkitRequestAnimationFrame'] || + window['msRequestAnimationFrame'] || + window['oRequestAnimationFrame'] || + window['setTimeout']; + } + window.requestAnimationFrame(func); + },getMovementX:function (event) { + return event['movementX'] || + event['mozMovementX'] || + event['webkitMovementX'] || + 0; + },getMovementY:function (event) { + return event['movementY'] || + event['mozMovementY'] || + event['webkitMovementY'] || + 0; + },xhrLoad:function (url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function() { + if (xhr.status == 200) { + onload(xhr.response); + } else { + onerror(); + } + }; + xhr.onerror = onerror; + xhr.send(null); + },asyncLoad:function (url, onload, onerror) { + Browser.xhrLoad(url, function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + removeRunDependency('al ' + url); + }, function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + addRunDependency('al ' + url); + },resizeListeners:[],updateResizeListeners:function () { + var canvas = Module['canvas']; + Browser.resizeListeners.forEach(function(listener) { + listener(canvas.width, canvas.height); + }); + },setCanvasSize:function (width, height, noUpdates) { + var canvas = Module['canvas']; + canvas.width = width; + canvas.height = height; + if (!noUpdates) Browser.updateResizeListeners(); + }}; +__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; +___setErrNo(0); +_fgetc.ret = allocate([0], "i8", ALLOC_STATIC); +_fputc.ret = allocate([0], "i8", ALLOC_STATIC); +Module["requestFullScreen"] = function() { Browser.requestFullScreen() }; + Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) }; + Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() }; + Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() }; + + +// === Auto-generated postamble setup entry stuff === + +Module.callMain = function callMain(args) { + var argc = args.length+1; + function pad() { + for (var i = 0; i < 4-1; i++) { + argv.push(0); + } + } + var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ]; + pad(); + for (var i = 0; i < argc-1; i = i + 1) { + argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC)); + pad(); + } + argv.push(0); + argv = allocate(argv, 'i32', ALLOC_STATIC); + + return _main(argc, argv, 0); +} + + + + +var _asm_instr; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _stderr; + +var _code_statements_data; +var _code_statements_elements; +var _code_statements_allocated; + +var _code_defs_data; +var _code_defs_elements; +var _code_defs_allocated; +var _code_fields_data; +var _code_fields_elements; +var _code_fields_allocated; +var _code_functions_data; +var _code_functions_elements; +var _code_functions_allocated; +var _code_globals_data; +var _code_globals_elements; +var _code_globals_allocated; +var _code_chars_data; +var _code_chars_elements; +var _code_chars_allocated; +var _code_entfields; +var _code_crc; + + + + + + + + + + + + + + + + + + +var _asm_instr138; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _levelcolor; + + + + + + + + + + + +var _type_name; +var _type_sizeof; +var _type_store_instr; +var _field_store_instr; +var _type_storep_instr; +var _type_eq_instr; +var _type_ne_instr; + + + + + + + + + +var _asm_instr231; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _lex_filenames_data; +var _lex_filenames_elements; +var _lex_filenames_allocated; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _opts_O; + +var _opts_output; +var _opts_standard; +var _opts_debug; +var _opts_memchk; +var _opts_dump; +var _opts_werror; +var _opts_forcecrc; +var _opts_pp_only; +var _operators; +var _operator_count; +var _items_data; +var _items_elements; +var _items_allocated; + +var _app_name; +var _opts_warn; +var _c_operators; +var _qcc_operators; + +var _opts_flag_list; +var _opts_flags; + +var _opts_warn_list; + + + + + + + + + + + + + + +var _opts_output_wasset; + + +var _opts_forced_crc; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _parser; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _mem_ab; +var _mem_db; +var _mem_at; +var _mem_dt; +var _mem_start; + + + + + + +var _stdout; + + + +var _util_crc16_table; +var __gm_; +var _mparams; +STRING_TABLE.__str=allocate([97,115,116,46,99,0] /* ast.c\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1=allocate([99,97,110,110,111,116,32,100,101,116,101,114,109,105,110,101,32,116,121,112,101,32,111,102,32,117,110,97,114,121,32,111,112,101,114,97,116,105,111,110,32,37,115,0] /* cannot determine typ */, "i8", ALLOC_STATIC); +_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); +STRING_TABLE.__str2=allocate([109,101,109,98,101,114,45,97,99,99,101,115,115,32,111,110,32,97,110,32,105,110,118,97,108,105,100,32,111,119,110,101,114,32,111,102,32,116,121,112,101,32,37,115,0] /* member-access on an */, "i8", ALLOC_STATIC); +STRING_TABLE.__str3=allocate([105,110,118,97,108,105,100,32,116,121,112,101,32,102,111,114,32,112,97,114,97,109,101,116,101,114,32,37,117,32,105,110,32,102,117,110,99,116,105,111,110,32,99,97,108,108,0] /* invalid type for par */, "i8", ALLOC_STATIC); +STRING_TABLE.__str4=allocate([97,115,116,95,118,97,108,117,101,32,117,115,101,100,32,98,101,102,111,114,101,32,103,101,110,101,114,97,116,101,100,32,40,37,115,41,0] /* ast_value used befor */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5=allocate([84,79,68,79,58,32,99,111,110,115,116,97,110,116,32,102,105,101,108,100,32,112,111,105,110,116,101,114,115,32,119,105,116,104,32,118,97,108,117,101,0] /* TODO: constant field */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6=allocate([105,114,95,98,117,105,108,100,101,114,95,99,114,101,97,116,101,95,103,108,111,98,97,108,32,102,97,105,108,101,100,0] /* ir_builder_create_gl */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7=allocate([103,108,111,98,97,108,32,111,102,32,116,121,112,101,32,102,117,110,99,116,105,111,110,32,110,111,116,32,112,114,111,112,101,114,108,121,32,103,101,110,101,114,97,116,101,100,0] /* global of type funct */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8=allocate([84,79,68,79,58,32,103,108,111,98,97,108,32,99,111,110,115,116,97,110,116,32,116,121,112,101,32,37,105,0] /* TODO: global constan */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9=allocate([97,115,116,95,102,117,110,99,116,105,111,110,39,115,32,114,101,108,97,116,101,100,32,97,115,116,95,118,97,108,117,101,32,119,97,115,32,110,111,116,32,103,101,110,101,114,97,116,101,100,32,121,101,116,0] /* ast_function's relat */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10=allocate([102,117,110,99,116,105,111,110,32,96,37,115,96,32,104,97,115,32,110,111,32,98,111,100,121,0] /* function `%s` has no */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11=allocate([101,110,116,114,121,0] /* entry\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,101,110,116,114,121,32,98,108,111,99,107,32,102,111,114,32,96,37,115,96,0] /* failed to allocate e */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13=allocate([110,111,116,32,97,110,32,108,45,118,97,108,117,101,32,40,99,111,100,101,45,98,108,111,99,107,41,0] /* not an l-value (code */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,108,111,99,97,108,32,96,37,115,96,0] /* failed to generate l */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15=allocate([110,111,116,32,97,110,32,108,45,118,97,108,117,101,32,40,98,105,110,111,112,41,0] /* not an l-value (bino */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16=allocate([98,105,110,0] /* bin\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17=allocate([98,105,110,115,116,0] /* binst\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str18=allocate([117,110,97,114,121,0] /* unary\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str19=allocate([114,101,116,117,114,110,45,101,120,112,114,101,115,115,105,111,110,32,105,115,32,110,111,116,32,97,110,32,108,45,118,97,108,117,101,0] /* return-expression is */, "i8", ALLOC_STATIC); +STRING_TABLE.__str20=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,97,115,116,95,114,101,116,117,114,110,32,99,97,110,110,111,116,32,98,101,32,114,101,117,115,101,100,44,32,105,116,32,98,101,97,114,115,32,110,111,32,114,101,115,117,108,116,33,0] /* internal error: ast_ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21=allocate([101,102,97,0] /* efa\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22=allocate([101,102,118,0] /* efv\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23=allocate([102,97,105,108,101,100,32,116,111,32,99,114,101,97,116,101,32,37,115,32,105,110,115,116,114,117,99,116,105,111,110,32,40,111,117,116,112,117,116,32,116,121,112,101,32,37,115,41,0] /* failed to create %s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25=allocate([70,73,69,76,68,0] /* FIELD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str26=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,97,115,116,95,105,102,116,104,101,110,32,99,97,110,110,111,116,32,98,101,32,114,101,117,115,101,100,44,32,105,116,32,98,101,97,114,115,32,110,111,32,114,101,115,117,108,116,33,0] /* internal error: ast_ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27=allocate([111,110,116,114,117,101,0] /* ontrue\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28=allocate([111,110,102,97,108,115,101,0] /* onfalse\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29=allocate([101,110,100,105,102,0] /* endif\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,97,115,116,95,108,111,111,112,32,99,97,110,110,111,116,32,98,101,32,114,101,117,115,101,100,44,32,105,116,32,98,101,97,114,115,32,110,111,32,114,101,115,117,108,116,33,0] /* internal error: ast_ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35=allocate([112,114,101,95,108,111,111,112,95,99,111,110,100,0] /* pre_loop_cond\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36=allocate([108,111,111,112,95,105,110,99,114,101,109,101,110,116,0] /* loop_increment\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37=allocate([112,111,115,116,95,108,111,111,112,95,99,111,110,100,0] /* post_loop_cond\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38=allocate([97,102,116,101,114,95,108,111,111,112,0] /* after_loop\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39=allocate([108,111,111,112,95,98,111,100,121,0] /* loop_body\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40=allocate([110,111,116,32,97,110,32,108,45,118,97,108,117,101,32,40,102,117,110,99,116,105,111,110,32,99,97,108,108,41,0] /* not an l-value (func */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41=allocate([99,97,108,108,0] /* call\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str63=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str64=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str94=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str95=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str96=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str97=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str98=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str99=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str100=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str101=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str102=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str103=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str104=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str105=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str106=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str107=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str108=allocate([101,114,114,111,114,0] /* error\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str109=allocate([40,110,117,108,108,41,0] /* (null)\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str110=allocate([40,118,97,114,105,97,110,116,41,0] /* (variant)\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str111=allocate([97,115,116,32,110,111,100,101,32,109,105,115,115,105,110,103,32,100,101,115,116,114,111,121,40,41,10,0] /* ast node missing des */, "i8", ALLOC_STATIC); +_code_statements_data=allocate(4, "i8", ALLOC_STATIC); +_code_statements_elements=allocate(4, "i8", ALLOC_STATIC); +_code_statements_allocated=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str112=allocate([99,111,100,101,46,99,0] /* code.c\00 */, "i8", ALLOC_STATIC); +_code_defs_data=allocate(4, "i8", ALLOC_STATIC); +_code_defs_elements=allocate(4, "i8", ALLOC_STATIC); +_code_defs_allocated=allocate(4, "i8", ALLOC_STATIC); +_code_fields_data=allocate(4, "i8", ALLOC_STATIC); +_code_fields_elements=allocate(4, "i8", ALLOC_STATIC); +_code_fields_allocated=allocate(4, "i8", ALLOC_STATIC); +_code_functions_data=allocate(4, "i8", ALLOC_STATIC); +_code_functions_elements=allocate(4, "i8", ALLOC_STATIC); +_code_functions_allocated=allocate(4, "i8", ALLOC_STATIC); +_code_globals_data=allocate(4, "i8", ALLOC_STATIC); +_code_globals_elements=allocate(4, "i8", ALLOC_STATIC); +_code_globals_allocated=allocate(4, "i8", ALLOC_STATIC); +_code_chars_data=allocate(4, "i8", ALLOC_STATIC); +_code_chars_elements=allocate(4, "i8", ALLOC_STATIC); +_code_chars_allocated=allocate(4, "i8", ALLOC_STATIC); +_code_entfields=allocate(4, "i8", ALLOC_STATIC); +_code_crc=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str8120=allocate([71,69,78,0] /* GEN\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9121=allocate([80,97,116,99,104,105,110,103,32,115,116,114,105,110,103,116,97,98,108,101,32,102,111,114,32,45,102,100,97,114,107,112,108,97,99,101,115,45,115,116,114,105,110,103,116,97,98,108,101,98,117,103,10,0] /* Patching stringtable */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10122=allocate([119,98,0] /* wb\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11123=allocate([72,69,65,68,69,82,58,10,0] /* HEADER:\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12124=allocate([32,32,32,32,118,101,114,115,105,111,110,58,32,32,32,32,61,32,37,100,10,0] /* version: = %d */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13125=allocate([32,32,32,32,99,114,99,49,54,58,32,32,32,32,32,32,61,32,37,100,10,0] /* crc16: = %d */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14126=allocate([32,32,32,32,101,110,116,102,105,101,108,100,58,32,32,32,61,32,37,100,10,0] /* entfield: = %d */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15127=allocate([32,32,32,32,115,116,97,116,101,109,101,110,116,115,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* statements = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16128=allocate([32,32,32,32,100,101,102,115,32,32,32,32,32,32,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* defs = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17129=allocate([32,32,32,32,102,105,101,108,100,115,32,32,32,32,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* fields = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str18130=allocate([32,32,32,32,102,117,110,99,116,105,111,110,115,32,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* functions = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str19131=allocate([32,32,32,32,103,108,111,98,97,108,115,32,32,32,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* globals = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str20132=allocate([32,32,32,32,115,116,114,105,110,103,115,32,32,32,32,32,61,32,123,46,111,102,102,115,101,116,32,61,32,37,32,56,100,44,32,46,108,101,110,103,116,104,32,61,32,37,32,56,100,125,10,0] /* strings = {. */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21133=allocate([70,85,78,67,84,73,79,78,83,58,10,0] /* FUNCTIONS:\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22134=allocate([32,32,32,32,123,46,101,110,116,114,121,32,61,37,32,53,100,44,32,46,102,105,114,115,116,108,111,99,97,108,32,61,37,32,53,100,44,32,46,108,111,99,97,108,115,32,61,37,32,53,100,44,32,46,112,114,111,102,105,108,101,32,61,37,32,53,100,44,32,46,110,97,109,101,32,61,37,32,53,100,44,32,46,102,105,108,101,32,61,37,32,53,100,44,32,46,110,97,114,103,115,32,61,37,32,53,100,44,32,46,97,114,103,115,105,122,101,32,61,123,37,100,44,37,100,44,37,100,44,37,100,44,37,100,44,37,100,44,37,100,44,37,100,125,32,125,10,0] /* {.entry =% 5d, . */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23135=allocate([32,32,32,32,78,65,77,69,58,32,37,115,10,0] /* NAME: %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24136=allocate([32,32,32,32,67,79,68,69,58,10,0] /* CODE:\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25137=allocate([32,32,32,32,32,32,32,32,37,45,49,50,115,32,123,37,32,53,105,44,37,32,53,105,44,37,32,53,105,125,10,0] /* %-12s {% 5i, */, "i8", ALLOC_STATIC); +_asm_instr138=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); +STRING_TABLE.__str26139=allocate([32,32,32,32,32,32,32,32,68,79,78,69,32,32,123,48,120,48,48,48,48,48,44,48,120,48,48,48,48,48,44,48,120,48,48,48,48,48,125,10,0] /* DONE {0x000 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27140=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28141=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29142=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30143=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31144=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str32145=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str33146=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34147=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35148=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36149=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37150=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38151=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39152=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40153=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41154=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42155=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43156=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44157=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45158=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46159=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47160=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48161=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49162=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50163=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51164=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52165=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53166=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54167=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55168=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56169=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57170=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58171=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59172=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60173=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61174=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62175=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str63176=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str64177=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65178=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66179=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67180=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68181=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69182=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70183=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71184=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72185=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73186=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74187=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75188=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76189=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77190=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78191=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79192=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80193=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81194=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82195=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83196=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84197=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85198=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86199=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87200=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88201=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89202=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90203=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91204=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92205=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93206=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC); +_levelcolor=allocate([37, 0, 0, 0, 36, 0, 0, 0, 31, 0, 0, 0], ["i32",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC); +STRING_TABLE.__str207=allocate([27,91,48,59,37,100,109,37,115,58,37,100,58,32,27,91,48,59,37,100,109,37,115,58,32,27,91,48,109,0] /* \1B[0;%dm%s:%d: \1B[ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1208=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str211=allocate([118,111,105,100,0] /* void\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1212=allocate([115,116,114,105,110,103,0] /* string\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str2213=allocate([102,108,111,97,116,0] /* float\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str3214=allocate([118,101,99,116,111,114,0] /* vector\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str4215=allocate([101,110,116,105,116,121,0] /* entity\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5216=allocate([102,105,101,108,100,0] /* field\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6217=allocate([102,117,110,99,116,105,111,110,0] /* function\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7218=allocate([112,111,105,110,116,101,114,0] /* pointer\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8219=allocate([118,97,114,105,97,110,116,0] /* variant\00 */, "i8", ALLOC_STATIC); +_type_name=allocate(40, "i8", ALLOC_STATIC); +_type_sizeof=allocate([1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0], ["i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC); +_type_store_instr=allocate([31, 0, 33, 0, 31, 0, 32, 0, 34, 0, 35, 0, 36, 0, 34, 0, 32, 0, 0, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +_field_store_instr=allocate([35, 0, 35, 0, 35, 0, 32, 0, 35, 0, 35, 0, 35, 0, 35, 0, 32, 0, 0, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +_type_storep_instr=allocate([37, 0, 39, 0, 37, 0, 38, 0, 40, 0, 41, 0, 42, 0, 40, 0, 38, 0, 0, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +_type_eq_instr=allocate([10, 0, 12, 0, 10, 0, 11, 0, 13, 0, 13, 0, 14, 0, 13, 0, 11, 0, 0, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +_type_ne_instr=allocate([15, 0, 17, 0, 15, 0, 16, 0, 18, 0, 18, 0, 19, 0, 18, 0, 16, 0, 0, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +STRING_TABLE.__str9222=allocate([105,114,46,99,0] /* ir.c\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10223=allocate([60,64,117,110,110,97,109,101,100,62,0] /* _@unnamed_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11224=allocate([60,64,110,111,32,99,111,110,116,101,120,116,62,0] /* _@no context_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12225=allocate([99,97,110,110,111,116,32,97,100,100,32,112,97,114,97,109,101,116,101,114,115,32,97,102,116,101,114,32,97,100,100,105,110,103,32,108,111,99,97,108,115,0] /* cannot add parameter */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13226=allocate([111,117,116,32,111,102,32,109,101,109,111,114,121,0] /* out of memory\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14227=allocate([105,110,118,97,108,105,100,32,109,101,109,98,101,114,32,97,99,99,101,115,115,32,111,110,32,37,115,0] /* invalid member acces */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15228=allocate([99,97,110,110,111,116,32,115,116,111,114,101,32,116,111,32,97,110,32,83,83,65,32,118,97,108,117,101,0] /* cannot store to an S */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16229=allocate([116,114,121,105,110,103,32,116,111,32,115,116,111,114,101,58,32,37,115,32,60,45,32,37,115,0] /* trying to store: %s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17230=allocate([105,110,115,116,114,117,99,116,105,111,110,58,32,37,115,0] /* instruction: %s\00 */, "i8", ALLOC_STATIC); +_asm_instr231=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); +STRING_TABLE.__str18232=allocate([98,108,111,99,107,32,97,108,114,101,97,100,121,32,101,110,100,101,100,32,40,37,115,41,0] /* block already ended */, "i8", ALLOC_STATIC); +STRING_TABLE.__str20234=allocate([118,97,114,105,97,98,108,101,32,96,37,115,96,32,109,97,121,32,98,101,32,117,115,101,100,32,117,110,105,110,105,116,105,97,108,105,122,101,100,32,105,110,32,116,104,105,115,32,102,117,110,99,116,105,111,110,0] /* variable `%s` may be */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21235=allocate([119,114,105,116,105,110,103,32,39,37,115,39,46,46,46,10,0] /* writing '%s'...\0A\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22236=allocate([60,73,78,86,65,76,73,68,62,0] /* _INVALID_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23237=allocate([80,72,73,0] /* PHI\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24238=allocate([74,85,77,80,0] /* JUMP\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25239=allocate([67,79,78,68,0] /* COND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str26240=allocate([60,85,78,75,62,0] /* _UNK_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27241=allocate([109,111,100,117,108,101,32,37,115,10,0] /* module %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28242=allocate([103,108,111,98,97,108,32,0] /* global \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29243=allocate([37,115,32,61,32,0] /* %s = \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30244=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31245=allocate([101,110,100,109,111,100,117,108,101,32,37,115,10,0] /* endmodule %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str32246=allocate([37,115,102,117,110,99,116,105,111,110,32,37,115,32,61,32,98,117,105,108,116,105,110,32,37,105,10,0] /* %sfunction %s = buil */, "i8", ALLOC_STATIC); +STRING_TABLE.__str33247=allocate([37,115,102,117,110,99,116,105,111,110,32,37,115,10,0] /* %sfunction %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34248=allocate([9,0] /* \09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35249=allocate([37,115,37,105,32,108,111,99,97,108,115,58,10,0] /* %s%i locals:\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36250=allocate([37,115,9,0] /* %s\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37251=allocate([37,115,108,105,102,101,114,97,110,103,101,115,58,10,0] /* %sliferanges:\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38252=allocate([37,115,9,37,115,58,32,117,110,105,113,117,101,32,0] /* %s\09%s: unique \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39253=allocate([91,37,105,44,37,105,93,32,0] /* [%i,%i] \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40254=allocate([37,115,9,37,115,58,32,64,37,105,32,0] /* %s\09%s: @%i \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41255=allocate([37,115,108,105,102,101,32,112,97,115,115,101,115,32,40,99,104,101,99,107,41,58,32,37,105,10,0] /* %slife passes (check */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42256=allocate([37,115,108,105,102,101,32,112,97,115,115,32,99,104,101,99,107,32,102,97,105,108,33,32,37,105,32,33,61,32,37,105,10,0] /* %slife pass check fa */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43257=allocate([37,115,101,110,100,102,117,110,99,116,105,111,110,32,37,115,10,0] /* %sendfunction %s\0A\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44258=allocate([37,115,58,37,115,10,0] /* %s:%s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45259=allocate([37,115,32,60,45,32,112,104,105,32,0] /* %s _- phi \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46260=allocate([40,91,37,115,93,32,58,32,37,115,41,32,0] /* ([%s] : %s) \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47261=allocate([37,115,32,40,37,105,41,32,0] /* %s (%i) \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48262=allocate([32,60,45,32,0] /* _- \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49263=allocate([67,65,76,76,37,105,9,0] /* CALL%i\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50264=allocate([44,9,0] /* ,\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51265=allocate([91,37,115,93,0] /* [%s]\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52266=allocate([37,115,91,37,115,93,0] /* %s[%s]\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53267=allocate([9,112,97,114,97,109,115,58,32,0] /* \09params: \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54268=allocate([37,115,44,32,0] /* %s, \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55269=allocate([40,118,111,105,100,41,0] /* (void)\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56270=allocate([102,110,58,37,115,0] /* fn:%s\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57271=allocate([37,103,0] /* %g\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58272=allocate([39,37,103,32,37,103,32,37,103,39,0] /* '%g %g %g'\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59273=allocate([40,101,110,116,105,116,121,41,0] /* (entity)\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60274=allocate([34,37,115,34,0] /* \22%s\22\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61275=allocate([38,37,115,0] /* &%s\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62276=allocate([37,115,0] /* %s\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65279=allocate([102,117,110,99,116,105,111,110,32,96,37,115,96,32,104,97,115,32,110,111,32,98,111,100,121,32,97,110,100,32,105,110,32,81,67,32,105,109,112,108,105,99,105,116,108,121,32,98,101,99,111,109,101,115,32,97,32,102,117,110,99,116,105,111,110,45,112,111,105,110,116,101,114,0] /* function `%s` has no */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66280=allocate([96,37,115,96,58,32,73,82,32,103,108,111,98,97,108,32,119,97,115,110,39,116,32,103,101,110,101,114,97,116,101,100,44,32,102,97,105,108,101,100,32,116,111,32,97,99,99,101,115,115,32,102,117,110,99,116,105,111,110,45,100,101,102,0] /* `%s`: IR global wasn */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67281=allocate([70,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,99,111,100,101,32,102,111,114,32,102,117,110,99,116,105,111,110,32,37,115,0] /* Failed to generate c */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68282=allocate([70,117,110,99,116,105,111,110,32,39,37,115,39,32,100,101,99,108,97,114,101,100,32,119,105,116,104,111,117,116,32,98,111,100,121,46,0] /* Function '%s' declar */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69283=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,98,108,111,99,107,115,32,102,111,114,32,39,37,115,39,0] /* failed to generate b */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70284=allocate([99,97,110,110,111,116,32,103,101,110,101,114,97,116,101,32,118,105,114,116,117,97,108,32,105,110,115,116,114,117,99,116,105,111,110,32,40,112,104,105,41,0] /* cannot generate virt */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71285=allocate([84,79,68,79,58,32,115,116,97,116,101,32,105,110,115,116,114,117,99,116,105,111,110,0] /* TODO: state instruct */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72286=allocate([105,110,118,97,108,105,100,32,102,105,101,108,100,32,110,97,109,101,32,115,105,122,101,58,32,37,117,0] /* invalid field name s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73287=allocate([102,105,101,108,100,32,105,115,32,109,105,115,115,105,110,103,32,97,32,116,121,112,101,58,32,37,115,32,45,32,100,111,110,39,116,32,107,110,111,119,32,105,116,115,32,115,105,122,101,0] /* field is missing a t */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74288=allocate([73,77,77,69,68,73,65,84,69,0] /* IMMEDIATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75289=allocate([101,110,100,95,115,121,115,95,103,108,111,98,97,108,115,0] /* end_sys_globals\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76290=allocate([101,110,100,95,115,121,115,95,102,105,101,108,100,115,0] /* end_sys_fields\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77291=allocate([117,110,114,101,99,111,103,110,105,122,101,100,32,118,97,114,105,97,98,108,101,32,111,102,32,116,121,112,101,32,118,111,105,100,32,96,37,115,96,0] /* unrecognized variabl */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78292=allocate([73,110,118,97,108,105,100,32,116,121,112,101,32,102,111,114,32,103,108,111,98,97,108,32,118,97,114,105,97,98,108,101,32,96,37,115,96,58,32,37,115,0] /* Invalid type for glo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79293=allocate([73,110,118,97,108,105,100,32,115,116,97,116,101,32,111,102,32,102,117,110,99,116,105,111,110,45,103,108,111,98,97,108,58,32,110,111,116,32,99,111,110,115,116,97,110,116,58,32,37,115,0] /* Invalid state of fun */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80294=allocate([70,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,108,111,99,97,108,32,37,115,0] /* Failed to generate l */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81295=allocate([73,110,118,97,108,105,100,32,102,105,101,108,100,32,99,111,110,115,116,97,110,116,32,119,105,116,104,32,110,111,32,102,105,101,108,100,58,32,37,115,0] /* Invalid field consta */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82296=allocate([70,73,88,77,69,58,32,82,101,108,111,99,97,116,105,111,110,32,115,117,112,112,111,114,116,0] /* FIXME: Relocation su */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83297=allocate([73,110,118,97,108,105,100,32,112,111,105,110,116,101,114,32,99,111,110,115,116,97,110,116,58,32,37,115,0] /* Invalid pointer cons */, "i8", ALLOC_STATIC); +STRING_TABLE._ir_block_life_propagate_dbg_ind=allocate([35,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0] /* #0\00\00\00\00\00\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84298=allocate([114,101,103,0] /* reg\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85299=allocate([119,97,114,110,105,110,103,0] /* warning\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86300=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87301=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88302=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89303=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90304=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91305=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92306=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93307=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str94308=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str95309=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str96310=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str97311=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str98312=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str99313=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str100314=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str101315=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str102316=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str103317=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str104318=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str105319=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str106320=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str107321=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str108322=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str109323=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str110324=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str111325=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str112326=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str113=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str114=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str115=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str116=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str117=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str118=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str119=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str120=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str121=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str122=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str123=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str124=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str125=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str126=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str127=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str128=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str129=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str130=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str131=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str132=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str133=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str134=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str135=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str136=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str137=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str138=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str139=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str140=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str141=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str142=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str143=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str144=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str145=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str146=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str147=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str148=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str149=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str150=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str151=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str152=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str153=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,0] /* internal error\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str385=allocate([108,101,120,101,114,46,99,0] /* lexer.c\00 */, "i8", ALLOC_STATIC); +_lex_filenames_data=allocate(4, "i8", ALLOC_STATIC); +_lex_filenames_elements=allocate(4, "i8", ALLOC_STATIC); +_lex_filenames_allocated=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str1386=allocate([112,97,114,115,101,32,101,114,114,111,114,0] /* parse error\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str2387=allocate([119,97,114,110,105,110,103,0] /* warning\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str3388=allocate([114,98,0] /* rb\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str4389=allocate([111,112,101,110,32,102,97,105,108,101,100,58,32,39,37,115,39,10,0] /* open failed: '%s'\0A */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5390=allocate([111,117,116,32,111,102,32,109,101,109,111,114,121,10,0] /* out of memory\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6391=allocate([60,115,116,114,105,110,103,45,115,111,117,114,99,101,62,0] /* _string-source_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7392=allocate([104,97,110,103,105,110,103,32,39,36,39,32,109,111,100,101,108,103,101,110,47,115,112,114,105,116,101,103,101,110,32,99,111,109,109,97,110,100,32,108,105,110,101,0] /* hanging '$' modelgen */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8393=allocate([102,114,97,109,101,0] /* frame\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9394=allocate([102,114,97,109,101,115,97,118,101,0] /* framesave\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10395=allocate([102,114,97,109,101,118,97,108,117,101,0] /* framevalue\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11396=allocate([36,102,114,97,109,101,118,97,108,117,101,32,114,101,113,117,105,114,101,115,32,97,110,32,105,110,116,101,103,101,114,32,112,97,114,97,109,101,116,101,114,0] /* $framevalue requires */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12397=allocate([102,114,97,109,101,114,101,115,116,111,114,101,0] /* framerestore\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13398=allocate([36,102,114,97,109,101,114,101,115,116,111,114,101,32,114,101,113,117,105,114,101,115,32,97,32,102,114,97,109,101,110,97,109,101,32,112,97,114,97,109,101,116,101,114,0] /* $framerestore requir */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14399=allocate([117,110,107,110,111,119,110,32,102,114,97,109,101,110,97,109,101,32,96,37,115,96,0] /* unknown framename `% */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15400=allocate([109,111,100,101,108,110,97,109,101,0] /* modelname\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16401=allocate([111,117,116,32,111,102,32,109,101,109,111,114,121,0] /* out of memory\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17402=allocate([102,108,117,115,104,0] /* flush\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str18403=allocate([99,100,0] /* cd\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str19404=allocate([111,114,105,103,105,110,0] /* origin\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str20405=allocate([98,97,115,101,0] /* base\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21406=allocate([102,108,97,103,115,0] /* flags\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22407=allocate([115,99,97,108,101,0] /* scale\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23408=allocate([115,107,105,110,0] /* skin\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24409=allocate([105,110,118,97,108,105,100,32,102,114,97,109,101,32,109,97,99,114,111,0] /* invalid frame macro\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25410=allocate([118,111,105,100,0] /* void\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str26411=allocate([105,110,116,0] /* int\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27412=allocate([102,108,111,97,116,0] /* float\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28413=allocate([115,116,114,105,110,103,0] /* string\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29414=allocate([101,110,116,105,116,121,0] /* entity\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30415=allocate([118,101,99,116,111,114,0] /* vector\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31416=allocate([102,111,114,0] /* for\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str32417=allocate([119,104,105,108,101,0] /* while\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str33418=allocate([100,111,0] /* do\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34419=allocate([105,102,0] /* if\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35420=allocate([101,108,115,101,0] /* else\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36421=allocate([108,111,99,97,108,0] /* local\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37422=allocate([114,101,116,117,114,110,0] /* return\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38423=allocate([99,111,110,115,116,0] /* const\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39424=allocate([115,119,105,116,99,104,0] /* switch\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40425=allocate([115,116,114,117,99,116,0] /* struct\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41426=allocate([117,110,105,111,110,0] /* union\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42427=allocate([98,114,101,97,107,0] /* break\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43428=allocate([99,111,110,116,105,110,117,101,0] /* continue\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44429=allocate([32,37,102,32,37,102,32,37,102,32,0] /* %f %f %f \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45430=allocate([117,110,107,110,111,119,110,32,116,111,107,101,110,0] /* unknown token\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46431=allocate([117,110,101,120,112,101,99,116,101,100,32,101,110,100,32,111,102,32,102,105,108,101,0] /* unexpected end of fi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47432=allocate([117,110,114,101,99,111,103,110,105,122,101,100,32,99,111,110,116,114,111,108,32,115,101,113,117,101,110,99,101,58,32,92,37,99,0] /* unrecognized control */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48433=allocate([117,110,101,120,112,101,99,116,101,100,32,101,110,100,32,111,102,32,102,105,108,101,32,119,105,116,104,105,110,32,115,116,114,105,110,103,32,99,111,110,115,116,97,110,116,0] /* unexpected end of fi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49434=allocate([105,110,118,97,108,105,100,32,102,114,97,109,101,110,97,109,101,44,32,109,117,115,116,32,115,116,97,114,116,32,119,105,116,104,32,111,110,101,32,111,102,32,97,45,122,32,111,114,32,95,44,32,103,111,116,32,37,99,0] /* invalid framename, m */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50435=allocate([117,110,101,120,112,101,99,116,101,100,32,116,114,97,105,108,105,110,103,32,99,104,97,114,97,99,116,101,114,115,32,97,102,116,101,114,32,110,117,109,98,101,114,0] /* unexpected trailing */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51436=allocate([100,117,112,108,105,99,97,116,101,32,102,114,97,109,101,32,109,97,99,114,111,32,100,101,102,105,110,101,100,58,32,96,37,115,96,0] /* duplicate frame macr */, "i8", ALLOC_STATIC); +_opts_O=allocate([1], ["i32",0,0,0], ALLOC_STATIC); +STRING_TABLE.__str437=allocate([112,114,111,103,115,46,100,97,116,0] /* progs.dat\00 */, "i8", ALLOC_STATIC); +_opts_output=allocate(4, "i8", ALLOC_STATIC); +_opts_standard=allocate([3], ["i32",0,0,0], ALLOC_STATIC); +_opts_debug=allocate(4, "i8", ALLOC_STATIC); +_opts_memchk=allocate(4, "i8", ALLOC_STATIC); +_opts_dump=allocate(4, "i8", ALLOC_STATIC); +_opts_werror=allocate(4, "i8", ALLOC_STATIC); +_opts_forcecrc=allocate(4, "i8", ALLOC_STATIC); +_opts_pp_only=allocate(4, "i8", ALLOC_STATIC); +_operators=allocate(4, "i8", ALLOC_STATIC); +_operator_count=allocate(4, "i8", ALLOC_STATIC); +_items_data=allocate(4, "i8", ALLOC_STATIC); +_items_elements=allocate(4, "i8", ALLOC_STATIC); +_items_allocated=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str1448=allocate([109,97,105,110,46,99,0] /* main.c\00 */, "i8", ALLOC_STATIC); +_app_name=allocate(4, "i8", ALLOC_STATIC); +_opts_warn=allocate(4, "i8", ALLOC_STATIC); +_c_operators=allocate([0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 5450539, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 5451053, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 8528, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 32336, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 11088, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 11600, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2829136, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2960720, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15420, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15934, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15421, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15933, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15677, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 8509, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9766, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 31868, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 16186, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 61, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 11069, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 11581, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 10813, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 12093, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9533, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4079165, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3947581, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9789, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 24125, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 31805, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], ["*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC); +_qcc_operators=allocate([0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 8528, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 11088, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 11600, 0, 0, 0, 1, 0, 0, 0, 14, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15421, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15933, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 15677, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 8509, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 61, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 11069, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 11581, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 10813, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 12093, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9533, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9789, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 31805, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 9766, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 31868, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], ["*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0,"i32",0,0,0], ALLOC_STATIC); +STRING_TABLE.__str2451=allocate([70,108,97,103,32,37,115,32,61,32,37,105,10,0] /* Flag %s = %i\0A\00 */, "i8", ALLOC_STATIC); +_opts_flag_list=allocate([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ["*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0], ALLOC_STATIC); +_opts_flags=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str3454=allocate([87,97,114,110,105,110,103,32,37,115,32,61,32,37,105,10,0] /* Warning %s = %i\0A\0 */, "i8", ALLOC_STATIC); +_opts_warn_list=allocate([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ["*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0,"*",0,0,0,"i32",0,0,0], ALLOC_STATIC); +STRING_TABLE.__str4455=allocate([111,117,116,112,117,116,32,61,32,37,115,10,0] /* output = %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5456=allocate([111,112,116,105,109,105,122,97,116,105,111,110,32,108,101,118,101,108,32,61,32,37,105,10,0] /* optimization level = */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6457=allocate([115,116,97,110,100,97,114,100,32,61,32,37,105,10,0] /* standard = %i\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7458=allocate([102,97,105,108,101,100,32,116,111,32,105,110,105,116,105,97,108,105,122,101,32,112,97,114,115,101,114,10,0] /* failed to initialize */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8459=allocate([67,79,77,0] /* COM\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9460=allocate([115,116,97,114,116,105,110,103,32,46,46,46,10,0] /* starting ...\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10461=allocate([77,111,100,101,58,32,109,97,110,117,97,108,10,0] /* Mode: manual\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11462=allocate([84,104,101,114,101,32,97,114,101,32,37,108,117,32,105,116,101,109,115,32,116,111,32,99,111,109,112,105,108,101,58,10,0] /* There are %lu items */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12463=allocate([106,115,46,113,99,0] /* js.qc\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13464=allocate([77,111,100,101,58,32,112,114,111,103,115,46,115,114,99,10,0] /* Mode: progs.src\0A\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14465=allocate([112,114,111,103,115,46,115,114,99,0] /* progs.src\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15466=allocate([114,98,0] /* rb\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16467=allocate([102,97,105,108,101,100,32,116,111,32,111,112,101,110,32,96,112,114,111,103,115,46,115,114,99,96,32,102,111,114,32,114,101,97,100,105,110,103,10,0] /* failed to open `prog */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17468=allocate([105,108,108,102,111,114,109,97,116,116,101,100,32,112,114,111,103,115,46,115,114,99,32,102,105,108,101,58,32,101,120,112,101,99,116,101,100,32,111,117,116,112,117,116,32,102,105,108,101,110,97,109,101,32,105,110,32,102,105,114,115,116,32,108,105,110,101,10,0] /* illformatted progs.s */, "i8", ALLOC_STATIC); +_opts_output_wasset=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str18469=allocate([32,32,115,114,99,58,32,37,115,10,0] /* src: %s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str19470=allocate([99,108,101,97,110,105,110,103,32,46,46,46,10,0] /* cleaning ...\0A\00 */, "i8", ALLOC_STATIC); +_opts_forced_crc=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str20473=allocate([68,69,66,85,71,0] /* DEBUG\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21474=allocate([85,78,85,83,69,68,95,86,65,82,73,65,66,76,69,0] /* UNUSED_VARIABLE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22475=allocate([85,83,69,68,95,85,78,73,78,73,84,73,65,76,73,90,69,68,0] /* USED_UNINITIALIZED\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23476=allocate([85,78,75,78,79,87,78,95,67,79,78,84,82,79,76,95,83,69,81,85,69,78,67,69,0] /* UNKNOWN_CONTROL_SEQU */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24477=allocate([69,88,84,69,78,83,73,79,78,83,0] /* EXTENSIONS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25478=allocate([70,73,69,76,68,95,82,69,68,69,67,76,65,82,69,68,0] /* FIELD_REDECLARED\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str26479=allocate([77,73,83,83,73,78,71,95,82,69,84,85,82,78,95,86,65,76,85,69,83,0] /* MISSING_RETURN_VALUE */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27480=allocate([84,79,79,95,70,69,87,95,80,65,82,65,77,69,84,69,82,83,0] /* TOO_FEW_PARAMETERS\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28481=allocate([76,79,67,65,76,95,83,72,65,68,79,87,83,0] /* LOCAL_SHADOWS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29482=allocate([76,79,67,65,76,95,67,79,78,83,84,65,78,84,83,0] /* LOCAL_CONSTANTS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30483=allocate([86,79,73,68,95,86,65,82,73,65,66,76,69,83,0] /* VOID_VARIABLES\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31484=allocate([73,77,80,76,73,67,73,84,95,70,85,78,67,84,73,79,78,95,80,79,73,78,84,69,82,0] /* IMPLICIT_FUNCTION_PO */, "i8", ALLOC_STATIC); +STRING_TABLE.__str32485=allocate([86,65,82,73,65,68,73,67,95,70,85,78,67,84,73,79,78,0] /* VARIADIC_FUNCTION\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str33486=allocate([70,82,65,77,69,95,77,65,67,82,79,83,0] /* FRAME_MACROS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34487=allocate([69,70,70,69,67,84,76,69,83,83,95,83,84,65,84,69,77,69,78,84,0] /* EFFECTLESS_STATEMENT */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35488=allocate([69,78,68,95,83,89,83,95,70,73,69,76,68,83,0] /* END_SYS_FIELDS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36489=allocate([65,83,83,73,71,78,95,70,85,78,67,84,73,79,78,95,84,89,80,69,83,0] /* ASSIGN_FUNCTION_TYPE */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37490=allocate([79,86,69,82,76,65,80,95,76,79,67,65,76,83,0] /* OVERLAP_LOCALS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38491=allocate([68,65,82,75,80,76,65,67,69,83,95,83,84,82,73,78,71,95,84,65,66,76,69,95,66,85,71,0] /* DARKPLACES_STRING_TA */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39492=allocate([79,77,73,84,95,78,85,76,76,95,66,89,84,69,83,0] /* OMIT_NULL_BYTES\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40493=allocate([65,68,74,85,83,84,95,86,69,67,84,79,82,95,70,73,69,76,68,83,0] /* ADJUST_VECTOR_FIELDS */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41494=allocate([40,0] /* (\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42495=allocate([46,0] /* .\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43496=allocate([33,0] /* !\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44497=allocate([43,0] /* +\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45498=allocate([45,0] /* -\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46499=allocate([42,0] /* _\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47500=allocate([47,0] /* /\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48501=allocate([38,0] /* &\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49502=allocate([124,0] /* |\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50503=allocate([60,0] /* _\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51504=allocate([62,0] /* _\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52505=allocate([60,61,0] /* _=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53506=allocate([62,61,0] /* _=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54507=allocate([61,61,0] /* ==\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55508=allocate([33,61,0] /* !=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56509=allocate([61,0] /* =\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57510=allocate([43,61,0] /* +=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58511=allocate([45,61,0] /* -=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59512=allocate([42,61,0] /* _=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60513=allocate([47,61,0] /* /=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61514=allocate([37,61,0] /* %=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62515=allocate([38,61,0] /* &=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str63516=allocate([124,61,0] /* |=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str64517=allocate([38,38,0] /* &&\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65518=allocate([124,124,0] /* ||\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66519=allocate([44,0] /* ,\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67520=allocate([43,43,0] /* ++\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68521=allocate([45,45,0] /* --\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69522=allocate([126,0] /* ~\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70523=allocate([37,0] /* %\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71524=allocate([60,60,0] /* __\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72525=allocate([62,62,0] /* __\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73526=allocate([94,0] /* ^\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74527=allocate([63,0] /* ?\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75528=allocate([62,62,61,0] /* __=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76529=allocate([60,60,61,0] /* __=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77530=allocate([94,61,0] /* ^=\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78531=allocate([117,115,97,103,101,58,32,37,115,32,91,111,112,116,105,111,110,115,93,32,91,102,105,108,101,115,46,46,46,93,0] /* usage: %s [options] */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79532=allocate([111,112,116,105,111,110,115,58,10,32,32,45,104,44,32,45,45,104,101,108,112,32,32,32,32,32,32,32,32,32,32,32,32,32,115,104,111,119,32,116,104,105,115,32,104,101,108,112,32,109,101,115,115,97,103,101,10,32,32,45,100,101,98,117,103,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,117,114,110,115,32,111,110,32,99,111,109,112,105,108,101,114,32,100,101,98,117,103,32,109,101,115,115,97,103,101,115,10,32,32,45,109,101,109,99,104,107,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,117,114,110,115,32,111,110,32,99,111,109,112,105,108,101,114,32,109,101,109,111,114,121,32,108,101,97,107,32,99,104,101,99,107,10,0] /* options:\0A -h, --h */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80533=allocate([32,32,45,111,44,32,45,45,111,117,116,112,117,116,61,102,105,108,101,32,32,32,32,32,32,111,117,116,112,117,116,32,102,105,108,101,44,32,100,101,102,97,117,108,116,115,32,116,111,32,112,114,111,103,115,46,100,97,116,10,32,32,45,97,32,102,105,108,101,110,97,109,101,32,32,32,32,32,32,32,32,32,32,32,32,97,100,100,32,97,110,32,97,115,109,32,102,105,108,101,32,116,111,32,98,101,32,97,115,115,101,109,98,108,101,100,10,32,32,45,115,32,102,105,108,101,110,97,109,101,32,32,32,32,32,32,32,32,32,32,32,32,97,100,100,32,97,32,112,114,111,103,115,46,115,114,99,32,102,105,108,101,32,116,111,32,98,101,32,117,115,101,100,10,0] /* -o, --output=file */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81534=allocate([32,32,45,69,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,115,116,111,112,32,97,102,116,101,114,32,112,114,101,112,114,111,99,101,115,115,105,110,103,10,0] /* -E */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82535=allocate([32,32,45,102,60,102,108,97,103,62,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,110,97,98,108,101,32,97,32,102,108,97,103,10,32,32,45,102,110,111,45,60,102,108,97,103,62,32,32,32,32,32,32,32,32,32,32,32,32,100,105,115,97,98,108,101,32,97,32,102,108,97,103,10,32,32,45,115,116,100,32,115,116,97,110,100,97,114,100,32,32,32,32,32,32,32,32,32,32,115,101,108,101,99,116,32,111,110,101,32,111,102,32,116,104,101,32,102,111,108,108,111,119,105,110,103,32,115,116,97,110,100,97,114,100,115,10,32,32,32,32,32,32,32,45,115,116,100,61,113,99,99,32,32,32,32,32,32,32,32,32,32,111,114,105,103,105,110,97,108,32,81,117,97,107,101,67,10,32,32,32,32,32,32,32,45,115,116,100,61,102,116,101,113,99,99,32,32,32,32,32,32,32,102,116,101,113,99,99,32,81,117,97,107,101,67,10,32,32,32,32,32,32,32,45,115,116,100,61,103,109,113,99,99,32,32,32,32,32,32,32,32,116,104,105,115,32,99,111,109,112,105,108,101,114,32,40,100,101,102,97,117,108,116,41,10,0] /* -f_flag_ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83536=allocate([32,32,45,87,60,119,97,114,110,105,110,103,62,32,32,32,32,32,32,32,32,32,32,32,32,101,110,97,98,108,101,32,97,32,119,97,114,110,105,110,103,10,32,32,45,87,110,111,45,60,119,97,114,110,105,110,103,62,32,32,32,32,32,32,32,32,32,100,105,115,97,98,108,101,32,97,32,119,97,114,110,105,110,103,10,32,32,45,87,97,108,108,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,101,110,97,98,108,101,32,97,108,108,32,119,97,114,110,105,110,103,115,10,32,32,45,87,101,114,114,111,114,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,116,114,101,97,116,32,119,97,114,110,105,110,103,115,32,97,115,32,101,114,114,111,114,115,10,0] /* -W_warning_ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84537=allocate([32,32,45,102,111,114,99,101,45,99,114,99,61,110,117,109,32,32,32,32,32,32,32,32,32,102,111,114,99,101,32,97,32,115,112,101,99,105,102,105,99,32,99,104,101,99,107,115,117,109,32,105,110,116,111,32,116,104,101,32,104,101,97,100,101,114,10,0] /* -force-crc=num */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85538=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86539=allocate([102,108,97,103,115,58,10,32,32,45,102,97,100,106,117,115,116,45,118,101,99,116,111,114,45,102,105,101,108,100,115,10,32,32,32,32,32,32,32,32,32,32,32,32,119,104,101,110,32,97,115,115,105,103,110,105,110,103,32,97,32,118,101,99,116,111,114,32,102,105,101,108,100,44,32,105,116,115,32,95,121,32,97,110,100,32,95,122,32,102,105,101,108,100,115,32,97,108,115,111,32,103,101,116,32,97,115,115,105,103,110,101,100,10,0] /* flags:\0A -fadjust- */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87540=allocate([115,116,100,0] /* std\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88541=allocate([103,109,113,99,99,0] /* gmqcc\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89542=allocate([100,101,102,97,117,108,116,0] /* default\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90543=allocate([113,99,99,0] /* qcc\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91544=allocate([102,116,101,0] /* fte\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92545=allocate([102,116,101,113,99,99,0] /* fteqcc\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93546=allocate([113,99,99,120,0] /* qccx\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str94547=allocate([85,110,107,110,111,119,110,32,115,116,97,110,100,97,114,100,58,32,37,115,10,0] /* Unknown standard: %s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str95548=allocate([102,111,114,99,101,45,99,114,99,0] /* force-crc\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str96549=allocate([100,101,98,117,103,0] /* debug\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str97550=allocate([100,117,109,112,0] /* dump\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str98551=allocate([109,101,109,99,104,107,0] /* memchk\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str99552=allocate([72,69,76,80,0] /* HELP\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str100553=allocate([80,111,115,115,105,98,108,101,32,102,108,97,103,115,58,10,0] /* Possible flags:\0A\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str101554=allocate([32,45,102,37,115,10,0] /* -f%s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str102555=allocate([78,79,95,0] /* NO_\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str103556=allocate([117,110,107,110,111,119,110,32,102,108,97,103,58,32,37,115,10,0] /* unknown flag: %s\0A\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str104557=allocate([80,111,115,115,105,98,108,101,32,119,97,114,110,105,110,103,115,58,10,0] /* Possible warnings:\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str105558=allocate([32,45,87,37,115,10,0] /* -W%s\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str106559=allocate([78,79,95,69,82,82,79,82,0] /* NO_ERROR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str107560=allocate([69,82,82,79,82,0] /* ERROR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str108561=allocate([78,79,78,69,0] /* NONE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str109562=allocate([65,76,76,0] /* ALL\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str110563=allocate([117,110,107,110,111,119,110,32,119,97,114,110,105,110,103,58,32,37,115,10,0] /* unknown warning: %s\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str111564=allocate([111,112,116,105,111,110,32,45,79,32,114,101,113,117,105,114,101,115,32,97,32,110,117,109,101,114,105,99,97,108,32,97,114,103,117,109,101,110,116,10,0] /* option -O requires a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str112565=allocate([111,112,116,105,111,110,32,45,111,32,114,101,113,117,105,114,101,115,32,97,110,32,97,114,103,117,109,101,110,116,58,32,116,104,101,32,111,117,116,112,117,116,32,102,105,108,101,32,110,97,109,101,10,0] /* option -o requires a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str113566=allocate([111,112,116,105,111,110,32,45,97,32,114,101,113,117,105,114,101,115,32,97,32,102,105,108,101,110,97,109,101,32,37,115,10,0] /* option -a requires a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str114567=allocate([99,111,110,116,97,105,110,105,110,103,32,81,67,45,97,115,109,0] /* containing QC-asm\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str115568=allocate([99,111,110,116,97,105,110,105,110,103,32,97,32,112,114,111,103,115,46,115,114,99,32,102,111,114,109,97,116,116,101,100,32,108,105,115,116,0] /* containing a progs.s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str116569=allocate([104,101,108,112,0] /* help\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str117570=allocate([111,117,116,112,117,116,0] /* output\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str118571=allocate([85,110,107,110,111,119,110,32,112,97,114,97,109,101,116,101,114,58,32,37,115,10,0] /* Unknown parameter: % */, "i8", ALLOC_STATIC); +STRING_TABLE.__str572=allocate([112,97,114,115,101,114,46,99,0] /* parser.c\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1573=allocate([108,101,120,32,101,114,114,111,114,0] /* lex error\00 */, "i8", ALLOC_STATIC); +_parser=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str2574=allocate([117,110,101,120,112,101,99,116,101,100,32,101,111,102,0] /* unexpected eof\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str3575=allocate([116,104,101,114,101,32,104,97,118,101,32,98,101,101,110,32,101,114,114,111,114,115,44,32,98,97,105,108,105,110,103,32,111,117,116,0] /* there have been erro */, "i8", ALLOC_STATIC); +STRING_TABLE.__str4576=allocate([112,97,114,115,101,32,101,114,114,111,114,0] /* parse error\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5577=allocate([102,97,105,108,101,100,32,116,111,32,111,112,101,110,32,102,105,108,101,32,34,37,115,34,10,0] /* failed to open file */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6578=allocate([102,97,105,108,101,100,32,116,111,32,99,114,101,97,116,101,32,108,101,120,101,114,32,102,111,114,32,115,116,114,105,110,103,32,34,37,115,34,10,0] /* failed to create lex */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7579=allocate([103,109,113,99,99,95,111,117,116,0] /* gmqcc_out\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8580=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,98,117,105,108,100,101,114,10,0] /* failed to allocate b */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9581=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,102,105,101,108,100,32,37,115,10,0] /* failed to generate f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str10582=allocate([101,110,100,95,115,121,115,95,103,108,111,98,97,108,115,0] /* end_sys_globals\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str11583=allocate([101,110,100,95,115,121,115,95,102,105,101,108,100,115,0] /* end_sys_fields\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str12584=allocate([117,110,117,115,101,100,32,103,108,111,98,97,108,58,32,96,37,115,96,0] /* unused global: `%s`\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str13585=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,103,108,111,98,97,108,32,37,115,10,0] /* failed to generate g */, "i8", ALLOC_STATIC); +STRING_TABLE.__str14586=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,102,117,110,99,116,105,111,110,32,37,115,10,0] /* failed to generate f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str15587=allocate([102,97,105,108,101,100,32,116,111,32,102,105,110,97,108,105,122,101,32,102,117,110,99,116,105,111,110,32,37,115,10,0] /* failed to finalize f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str16588=allocate([42,42,42,32,102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,111,117,116,112,117,116,32,102,105,108,101,10,0] /* ___ failed to genera */, "i8", ALLOC_STATIC); +STRING_TABLE.__str17589=allocate([42,42,42,32,116,104,101,114,101,32,119,101,114,101,32,99,111,109,112,105,108,101,32,101,114,114,111,114,115,10,0] /* ___ there were compi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str18590=allocate([10,47,42,32,102,105,108,101,32,103,101,110,101,114,97,116,101,100,32,98,121,32,113,99,99,44,32,100,111,32,110,111,116,32,109,111,100,105,102,121,32,42,47,10,10,116,121,112,101,100,101,102,32,115,116,114,117,99,116,10,123,0] /* \0A/_ file generated */, "i8", ALLOC_STATIC); +STRING_TABLE.__str19591=allocate([9,105,110,116,9,112,97,100,91,50,56,93,59,10,0] /* \09int\09pad[28];\0A */, "i8", ALLOC_STATIC); +STRING_TABLE.__str20592=allocate([9,102,108,111,97,116,9,0] /* \09float\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str21593=allocate([9,118,101,99,51,95,116,9,0] /* \09vec3_t\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str22594=allocate([9,115,116,114,105,110,103,95,116,9,0] /* \09string_t\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str23595=allocate([9,102,117,110,99,95,116,9,0] /* \09func_t\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str24596=allocate([9,105,110,116,9,0] /* \09int\09\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str25597=allocate([59,10,0] /* ;\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str26598=allocate([125,32,103,108,111,98,97,108,118,97,114,115,95,116,59,10,10,116,121,112,101,100,101,102,32,115,116,114,117,99,116,10,123,10,0] /* } globalvars_t;\0A\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str27599=allocate([125,32,101,110,116,118,97,114,115,95,116,59,10,10,0] /* } entvars_t;\0A\0A\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str28600=allocate([119,97,114,110,105,110,103,0] /* warning\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str29601=allocate([117,110,101,120,112,101,99,116,101,100,32,116,111,107,101,110,58,32,37,115,0] /* unexpected token: %s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30602=allocate([101,120,112,101,99,116,101,100,32,116,121,112,101,110,97,109,101,32,102,111,114,32,102,105,101,108,100,32,100,101,102,105,110,105,116,105,111,110,0] /* expected typename fo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31603=allocate([101,120,112,101,99,116,101,100,32,118,97,114,105,97,98,108,101,32,100,101,102,105,110,105,116,105,111,110,0] /* expected variable de */, "i8", ALLOC_STATIC); +STRING_TABLE.__str32604=allocate([102,97,105,108,101,100,32,116,111,32,99,114,101,97,116,101,32,118,97,114,105,97,98,108,101,0] /* failed to create var */, "i8", ALLOC_STATIC); +STRING_TABLE.__str33605=allocate([101,120,112,101,99,116,101,100,32,118,97,114,105,97,98,108,101,32,110,97,109,101,0] /* expected variable na */, "i8", ALLOC_STATIC); +STRING_TABLE.__str34606=allocate([103,108,111,98,97,108,32,39,37,115,39,32,104,105,110,116,32,115,104,111,117,108,100,32,110,111,116,32,98,101,32,97,32,102,105,101,108,100,0] /* global '%s' hint sho */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35607=allocate([102,97,105,108,101,100,32,116,111,32,115,101,116,32,118,97,114,105,97,98,108,101,32,110,97,109,101,10,0] /* failed to set variab */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36608=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,97,32,102,117,110,99,116,105,111,110,32,119,105,116,104,32,116,104,101,32,115,97,109,101,32,110,97,109,101,32,97,115,32,97,32,118,101,99,116,111,114,39,115,32,109,101,109,98,101,114,58,32,37,115,0] /* cannot declare a fun */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37609=allocate([99,111,110,102,108,105,99,116,105,110,103,32,116,121,112,101,115,32,102,111,114,32,96,37,115,96,44,32,112,114,101,118,105,111,117,115,32,100,101,99,108,97,114,97,116,105,111,110,32,119,97,115,32,104,101,114,101,58,32,37,115,58,37,105,0] /* conflicting types fo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38610=allocate([103,108,111,98,97,108,32,96,37,115,96,32,97,108,114,101,97,100,121,32,100,101,99,108,97,114,101,100,32,104,101,114,101,58,32,37,115,58,37,105,0] /* global `%s` already */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39611=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,97,32,102,105,101,108,100,32,97,110,100,32,97,32,103,108,111,98,97,108,32,111,102,32,116,104,101,32,115,97,109,101,32,110,97,109,101,32,119,105,116,104,32,45,115,116,100,61,113,99,99,0] /* cannot declare a fie */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40612=allocate([102,105,101,108,100,32,96,37,115,96,32,97,108,114,101,97,100,121,32,100,101,99,108,97,114,101,100,32,104,101,114,101,58,32,37,115,58,37,105,0] /* field `%s` already d */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41613=allocate([102,105,101,108,100,32,37,115,32,104,97,115,32,112,114,101,118,105,111,117,115,108,121,32,98,101,101,110,32,100,101,99,108,97,114,101,100,32,119,105,116,104,32,97,32,100,105,102,102,101,114,101,110,116,32,116,121,112,101,32,104,101,114,101,58,32,37,115,58,37,105,0] /* field %s has previou */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42614=allocate([108,111,99,97,108,32,96,37,115,96,32,97,108,114,101,97,100,121,32,100,101,99,108,97,114,101,100,32,104,101,114,101,58,32,37,115,58,37,105,0] /* local `%s` already d */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43615=allocate([108,111,99,97,108,32,96,37,115,96,32,105,115,32,115,104,97,100,111,119,105,110,103,32,97,32,112,97,114,97,109,101,116,101,114,0] /* local `%s` is shadow */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44616=allocate([97,32,112,97,114,97,109,101,116,101,114,32,105,115,32,115,104,97,100,111,119,105,110,103,32,108,111,99,97,108,32,96,37,115,96,0] /* a parameter is shado */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45617=allocate([109,105,115,115,105,110,103,32,115,101,109,105,99,111,108,111,110,0] /* missing semicolon\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46618=allocate([105,110,105,116,105,97,108,105,122,105,110,103,32,101,120,112,114,101,115,115,105,111,110,32,116,117,114,110,115,32,118,97,114,105,97,98,108,101,32,96,37,115,96,32,105,110,116,111,32,97,32,99,111,110,115,116,97,110,116,32,105,110,32,116,104,105,115,32,115,116,97,110,100,97,114,100,0] /* initializing express */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47619=allocate([109,105,115,115,105,110,103,32,115,101,109,105,99,111,108,111,110,32,111,114,32,105,110,105,116,105,97,108,105,122,101,114,0] /* missing semicolon or */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48620=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,98,117,105,108,116,105,110,115,32,119,105,116,104,105,110,32,102,117,110,99,116,105,111,110,115,0] /* cannot declare built */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49621=allocate([117,110,101,120,112,101,99,116,101,100,32,98,117,105,108,116,105,110,32,110,117,109,98,101,114,44,32,39,37,115,39,32,105,115,32,110,111,116,32,97,32,102,117,110,99,116,105,111,110,0] /* unexpected builtin n */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50622=allocate([101,120,112,101,99,116,101,100,32,98,117,105,108,116,105,110,32,110,117,109,98,101,114,0] /* expected builtin num */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51623=allocate([98,117,105,108,116,105,110,32,110,117,109,98,101,114,32,109,117,115,116,32,98,101,32,97,110,32,105,110,116,101,103,101,114,32,99,111,110,115,116,97,110,116,0] /* builtin number must */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52624=allocate([98,117,105,108,116,105,110,32,110,117,109,98,101,114,32,109,117,115,116,32,98,101,32,112,111,115,105,116,105,118,101,32,105,110,116,101,103,101,114,32,103,114,101,97,116,101,114,32,116,104,97,110,32,122,101,114,111,0] /* builtin number must */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53625=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,102,117,110,99,116,105,111,110,32,102,111,114,32,96,37,115,96,0] /* failed to allocate f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54626=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,115,108,111,116,32,102,111,114,32,102,117,110,99,116,105,111,110,32,96,37,115,96,0] /* failed to allocate s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55627=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,102,117,110,99,116,105,111,110,115,32,119,105,116,104,105,110,32,102,117,110,99,116,105,111,110,115,0] /* cannot declare funct */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56628=allocate([99,97,110,110,111,116,32,105,110,105,116,105,97,108,105,122,101,32,97,32,103,108,111,98,97,108,32,99,111,110,115,116,97,110,116,32,118,97,114,105,97,98,108,101,32,119,105,116,104,32,97,32,110,111,110,45,99,111,110,115,116,97,110,116,32,101,120,112,114,101,115,115,105,111,110,0] /* cannot initialize a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57629=allocate([101,120,112,101,99,116,101,100,32,111,112,101,114,97,116,111,114,32,111,114,32,101,110,100,32,111,102,32,115,116,97,116,101,109,101,110,116,0] /* expected operator or */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58630=allocate([84,79,68,79,58,32,105,109,112,108,101,109,101,110,116,32,101,102,102,101,99,116,105,118,101,32,118,101,99,116,111,114,32,109,101,109,98,101,114,32,97,99,99,101,115,115,0] /* TODO: implement effe */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59631=allocate([110,97,109,101,115,112,97,99,101,32,102,111,114,32,109,101,109,98,101,114,32,110,111,116,32,102,111,117,110,100,0] /* namespace for member */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60632=allocate([117,110,101,120,112,101,99,116,101,100,32,105,100,101,110,116,58,32,37,115,0] /* unexpected ident: %s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61633=allocate([111,117,116,32,111,102,32,109,101,109,111,114,121,0] /* out of memory\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62634=allocate([101,120,112,101,99,116,101,100,32,111,112,101,114,97,116,111,114,32,111,114,32,101,110,100,32,111,102,32,115,116,97,116,101,109,101,110,116,44,32,103,111,116,32,99,111,110,115,116,97,110,116,0] /* expected operator or */, "i8", ALLOC_STATIC); +STRING_TABLE.__str63635=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,39,40,39,32,115,104,111,117,108,100,32,98,101,32,99,108,97,115,115,105,102,105,101,100,32,97,115,32,111,112,101,114,97,116,111,114,0] /* internal error: '(' */, "i8", ALLOC_STATIC); +STRING_TABLE.__str64636=allocate([117,110,101,120,112,101,99,116,101,100,32,109,101,109,98,101,114,32,111,112,101,114,97,116,111,114,0] /* unexpected member op */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65637=allocate([116,121,112,101,32,101,114,114,111,114,58,32,116,121,112,101,32,104,97,115,32,110,111,32,109,101,109,98,101,114,115,0] /* type error: type has */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66638=allocate([101,109,112,116,121,32,101,120,112,114,101,115,115,105,111,110,0] /* empty expression\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67639=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,109,105,115,115,105,110,103,32,111,112,101,114,97,116,111,114,0] /* internal error: miss */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68640=allocate([117,110,109,97,116,99,104,101,100,32,112,97,114,101,110,116,104,101,115,105,115,0] /* unmatched parenthesi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69641=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,110,111,116,32,101,110,111,117,103,104,32,111,112,101,114,97,110,100,115,58,32,37,105,32,40,111,112,101,114,97,116,111,114,32,37,115,32,40,37,105,41,41,0] /* internal error: not */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70642=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,111,112,101,114,97,116,111,114,32,99,97,110,110,111,116,32,98,101,32,97,112,112,108,105,101,100,32,111,110,32,101,109,112,116,121,32,98,108,111,99,107,115,0] /* internal error: oper */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71643=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,117,110,104,97,110,100,108,101,100,32,111,112,101,114,97,116,111,114,58,32,37,115,32,40,37,105,41,0] /* internal error: unha */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72644=allocate([116,121,112,101,32,101,114,114,111,114,58,32,114,105,103,104,116,32,104,97,110,100,32,111,102,32,109,101,109,98,101,114,45,111,112,101,114,97,110,100,32,115,104,111,117,108,100,32,98,101,32,97,110,32,101,110,116,105,116,121,45,102,105,101,108,100,0] /* type error: right ha */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73645=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,118,101,99,116,111,114,32,97,99,99,101,115,115,32,105,115,32,110,111,116,32,115,117,112,112,111,115,101,100,32,116,111,32,98,101,32,104,97,110,100,108,101,100,32,97,116,32,116,104,105,115,32,112,111,105,110,116,0] /* internal error: vect */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74646=allocate([116,121,112,101,32,101,114,114,111,114,58,32,109,101,109,98,101,114,45,111,102,32,111,112,101,114,97,116,111,114,32,111,110,32,115,111,109,101,116,104,105,110,103,32,116,104,97,116,32,105,115,32,110,111,116,32,97,110,32,101,110,116,105,116,121,32,111,114,32,118,101,99,116,111,114,0] /* type error: member-o */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75647=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,110,101,103,97,116,101,32,116,121,112,101,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76648=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,108,111,103,105,99,97,108,108,121,32,110,101,103,97,116,101,32,116,121,112,101,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77649=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,97,100,100,32,116,121,112,101,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78650=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,115,117,98,116,114,97,99,116,32,116,121,112,101,32,37,115,32,102,114,111,109,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79651=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,109,117,108,116,105,112,108,121,32,116,121,112,101,115,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80652=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,100,105,118,105,100,101,32,116,121,112,101,115,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81653=allocate([113,99,32,100,111,101,115,32,110,111,116,32,104,97,118,101,32,97,32,109,111,100,117,108,111,32,111,112,101,114,97,116,111,114,0] /* qc does not have a m */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82654=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,112,101,114,102,111,114,109,32,98,105,116,32,111,112,101,114,97,116,105,111,110,115,32,98,101,116,119,101,101,110,32,116,121,112,101,115,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83655=allocate([84,79,68,79,58,32,98,105,116,120,111,114,0] /* TODO: bitxor\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84656=allocate([84,79,68,79,58,32,115,104,105,102,116,115,0] /* TODO: shifts\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85657=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,112,101,114,102,111,114,109,32,108,111,103,105,99,97,108,32,111,112,101,114,97,116,105,111,110,115,32,98,101,116,119,101,101,110,32,116,121,112,101,115,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86658=allocate([84,79,68,79,58,32,108,111,103,105,99,97,108,32,111,112,115,32,102,111,114,32,97,114,98,105,116,114,97,114,121,32,116,121,112,101,115,32,117,115,105,110,103,32,73,78,83,84,82,95,78,79,84,0] /* TODO: logical ops fo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87659=allocate([84,79,68,79,58,32,111,112,116,105,111,110,97,108,32,101,97,114,108,121,32,111,117,116,0] /* TODO: optional early */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88660=allocate([84,79,68,79,58,32,101,97,114,108,121,32,111,117,116,32,108,111,103,105,99,10,0] /* TODO: early out logi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89661=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,112,101,114,102,111,114,109,32,99,111,109,112,97,114,105,115,111,110,32,98,101,116,119,101,101,110,32,116,121,112,101,115,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90662=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,105,110,32,97,115,115,105,103,110,109,101,110,116,58,32,99,97,110,110,111,116,32,97,115,115,105,103,110,32,37,115,32,116,111,32,37,115,0] /* invalid types in ass */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91663=allocate([105,110,118,97,108,105,100,32,116,121,112,101,115,32,117,115,101,100,32,105,110,32,101,120,112,114,101,115,115,105,111,110,58,32,99,97,110,110,111,116,32,97,100,100,32,111,114,32,115,117,98,116,114,97,99,116,32,116,121,112,101,32,37,115,32,97,110,100,32,37,115,0] /* invalid types used i */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92664=allocate([102,97,105,108,101,100,32,116,111,32,97,112,112,108,121,32,111,112,101,114,97,110,100,32,37,115,0] /* failed to apply oper */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93665=allocate([117,110,109,97,116,99,104,101,100,32,99,108,111,115,105,110,103,32,112,97,114,101,110,0] /* unmatched closing pa */, "i8", ALLOC_STATIC); +STRING_TABLE.__str94666=allocate([105,110,116,101,114,110,97,108,32,101,114,114,111,114,58,32,102,117,110,99,116,105,111,110,32,99,97,108,108,32,110,101,101,100,115,32,102,117,110,99,116,105,111,110,32,97,110,100,32,112,97,114,97,109,101,116,101,114,32,108,105,115,116,46,46,46,0] /* internal error: func */, "i8", ALLOC_STATIC); +STRING_TABLE.__str95667=allocate([105,110,118,97,108,105,100,32,102,117,110,99,116,105,111,110,32,99,97,108,108,0] /* invalid function cal */, "i8", ALLOC_STATIC); +STRING_TABLE.__str96668=allocate([110,111,116,32,97,32,102,117,110,99,116,105,111,110,32,40,37,115,41,0] /* not a function (%s)\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str97669=allocate([99,111,117,108,100,32,110,111,116,32,100,101,116,101,114,109,105,110,101,32,102,117,110,99,116,105,111,110,32,114,101,116,117,114,110,32,116,121,112,101,0] /* could not determine */, "i8", ALLOC_STATIC); +STRING_TABLE.__str98670=allocate([102,101,119,0] /* few\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str99671=allocate([109,97,110,121,0] /* many\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str100672=allocate([116,111,111,32,37,115,32,112,97,114,97,109,101,116,101,114,115,32,102,111,114,32,99,97,108,108,32,116,111,32,37,115,58,32,101,120,112,101,99,116,101,100,32,37,105,44,32,103,111,116,32,37,105,10,32,45,62,32,96,37,115,96,32,104,97,115,32,98,101,101,110,32,100,101,99,108,97,114,101,100,32,104,101,114,101,58,32,37,115,58,37,105,0] /* too %s parameters fo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str101673=allocate([116,111,111,32,37,115,32,112,97,114,97,109,101,116,101,114,115,32,102,111,114,32,102,117,110,99,116,105,111,110,32,99,97,108,108,58,32,101,120,112,101,99,116,101,100,32,37,105,44,32,103,111,116,32,37,105,10,32,45,62,32,96,37,115,96,32,104,97,115,32,98,101,101,110,32,100,101,99,108,97,114,101,100,32,104,101,114,101,58,32,37,115,58,37,105,0] /* too %s parameters fo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str102674=allocate([35,73,77,77,69,68,73,65,84,69,0] /* #IMMEDIATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str103675=allocate([118,97,114,105,97,100,105,99,32,102,117,110,99,116,105,111,110,32,119,105,116,104,32,105,109,112,108,101,109,101,110,116,97,116,105,111,110,32,119,105,108,108,32,110,111,116,32,98,101,32,97,98,108,101,32,116,111,32,97,99,99,101,115,115,32,97,100,100,105,116,105,111,110,97,108,32,112,97,114,97,109,101,116,101,114,115,0] /* variadic function wi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str104676=allocate([116,104,105,110,107,0] /* think\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str105677=allocate([110,101,120,116,116,104,105,110,107,0] /* nextthink\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str106678=allocate([102,114,97,109,101,0] /* frame\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str107679=allocate([99,97,110,110,111,116,32,117,115,101,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,32,119,105,116,104,111,117,116,32,116,104,101,32,114,101,113,117,105,114,101,100,32,102,105,101,108,100,115,0] /* cannot use [frame,th */, "i8", ALLOC_STATIC); +STRING_TABLE.__str108680=allocate([112,108,101,97,115,101,32,100,101,99,108,97,114,101,32,116,104,101,32,102,111,108,108,111,119,105,110,103,32,101,110,116,105,116,121,102,105,101,108,100,115,58,32,96,102,114,97,109,101,96,44,32,96,116,104,105,110,107,96,44,32,96,110,101,120,116,116,104,105,110,107,96,0] /* please declare the f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str109681=allocate([116,105,109,101,0] /* time\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str110682=allocate([115,101,108,102,0] /* self\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str111683=allocate([99,97,110,110,111,116,32,117,115,101,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,32,119,105,116,104,111,117,116,32,116,104,101,32,114,101,113,117,105,114,101,100,32,103,108,111,98,97,108,115,0] /* cannot use [frame,th */, "i8", ALLOC_STATIC); +STRING_TABLE.__str112684=allocate([112,108,101,97,115,101,32,100,101,99,108,97,114,101,32,116,104,101,32,102,111,108,108,111,119,105,110,103,32,103,108,111,98,97,108,115,58,32,96,116,105,109,101,96,44,32,96,115,101,108,102,96,0] /* please declare the f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str113685=allocate([101,120,112,101,99,116,101,100,32,97,32,102,114,97,109,101,110,117,109,98,101,114,32,99,111,110,115,116,97,110,116,32,105,110,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,0] /* expected a framenumb */, "i8", ALLOC_STATIC); +STRING_TABLE.__str114686=allocate([102,114,97,109,101,110,117,109,98,101,114,32,105,110,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,32,109,117,115,116,32,98,101,32,97,32,99,111,110,115,116,97,110,116,0] /* framenumber in [fram */, "i8", ALLOC_STATIC); +STRING_TABLE.__str115687=allocate([101,120,112,101,99,116,101,100,32,99,111,109,109,97,32,97,102,116,101,114,32,102,114,97,109,101,32,110,117,109,98,101,114,32,105,110,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,0] /* expected comma after */, "i8", ALLOC_STATIC); +STRING_TABLE.__str116688=allocate([71,111,116,32,97,32,37,105,10,0] /* Got a %i\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str117689=allocate([102,97,105,108,101,100,32,116,111,32,99,114,101,97,116,101,32,105,109,112,108,105,99,105,116,32,112,114,111,116,111,116,121,112,101,32,102,111,114,32,96,37,115,96,0] /* failed to create imp */, "i8", ALLOC_STATIC); +STRING_TABLE.__str118690=allocate([101,120,112,101,99,116,101,100,32,97,32,116,104,105,110,107,45,102,117,110,99,116,105,111,110,32,105,110,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,0] /* expected a think-fun */, "i8", ALLOC_STATIC); +STRING_TABLE.__str119691=allocate([116,104,105,110,107,45,102,117,110,99,116,105,111,110,32,105,110,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,32,109,117,115,116,32,98,101,32,97,32,99,111,110,115,116,97,110,116,0] /* think-function in [f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str120692=allocate([101,120,112,101,99,116,101,100,32,99,108,111,115,105,110,103,32,96,93,96,32,102,111,114,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,110,111,116,97,116,105,111,110,0] /* expected closing `]` */, "i8", ALLOC_STATIC); +STRING_TABLE.__str121693=allocate([97,32,102,117,110,99,116,105,111,110,32,98,111,100,121,32,104,97,115,32,116,111,32,98,101,32,100,101,99,108,97,114,101,100,32,97,102,116,101,114,32,97,32,91,102,114,97,109,101,44,116,104,105,110,107,93,32,100,101,99,108,97,114,97,116,105,111,110,0] /* a function body has */, "i8", ALLOC_STATIC); +STRING_TABLE.__str122694=allocate([102,97,105,108,101,100,32,116,111,32,97,108,108,111,99,97,116,101,32,98,108,111,99,107,0] /* failed to allocate b */, "i8", ALLOC_STATIC); +STRING_TABLE.__str123695=allocate([102,97,105,108,101,100,32,116,111,32,103,101,110,101,114,97,116,101,32,99,111,100,101,32,102,111,114,32,91,102,114,97,109,101,44,116,104,105,110,107,93,0] /* failed to generate c */, "i8", ALLOC_STATIC); +STRING_TABLE.__str124696=allocate([109,105,115,115,105,110,103,32,115,101,109,105,99,111,108,111,110,32,97,102,116,101,114,32,102,117,110,99,116,105,111,110,32,98,111,100,121,32,40,109,97,110,100,97,116,111,114,121,32,119,105,116,104,32,45,115,116,100,61,113,99,99,41,0] /* missing semicolon af */, "i8", ALLOC_STATIC); +STRING_TABLE.__str125697=allocate([117,110,117,115,101,100,32,118,97,114,105,97,98,108,101,58,32,96,37,115,96,0] /* unused variable: `%s */, "i8", ALLOC_STATIC); +STRING_TABLE.__str126698=allocate([101,120,112,101,99,116,101,100,32,102,117,110,99,116,105,111,110,32,98,111,100,121,0] /* expected function bo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str127699=allocate([99,111,110,116,114,111,108,32,114,101,97,99,104,101,115,32,101,110,100,32,111,102,32,110,111,110,45,118,111,105,100,32,102,117,110,99,116,105,111,110,0] /* control reaches end */, "i8", ALLOC_STATIC); +STRING_TABLE.__str128700=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,97,32,118,97,114,105,97,98,108,101,32,102,114,111,109,32,104,101,114,101,0] /* cannot declare a var */, "i8", ALLOC_STATIC); +STRING_TABLE.__str129701=allocate([109,105,115,115,105,110,103,32,39,108,111,99,97,108,39,32,107,101,121,119,111,114,100,32,119,104,101,110,32,100,101,99,108,97,114,105,110,103,32,97,32,108,111,99,97,108,32,118,97,114,105,97,98,108,101,0] /* missing 'local' keyw */, "i8", ALLOC_STATIC); +STRING_TABLE.__str130702=allocate([108,111,99,97,108,0] /* local\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str131703=allocate([99,97,110,110,111,116,32,100,101,99,108,97,114,101,32,97,32,108,111,99,97,108,32,118,97,114,105,97,98,108,101,32,104,101,114,101,0] /* cannot declare a loc */, "i8", ALLOC_STATIC); +STRING_TABLE.__str132704=allocate([101,120,112,101,99,116,101,100,32,118,97,114,105,97,98,108,101,32,100,101,99,108,97,114,97,116,105,111,110,0] /* expected variable de */, "i8", ALLOC_STATIC); +STRING_TABLE.__str133705=allocate([114,101,116,117,114,110,0] /* return\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str134706=allocate([101,120,112,101,99,116,101,100,32,114,101,116,117,114,110,32,101,120,112,114,101,115,115,105,111,110,0] /* expected return expr */, "i8", ALLOC_STATIC); +STRING_TABLE.__str135707=allocate([114,101,116,117,114,110,32,119,105,116,104,32,105,110,118,97,108,105,100,32,101,120,112,114,101,115,115,105,111,110,0] /* return with invalid */, "i8", ALLOC_STATIC); +STRING_TABLE.__str136708=allocate([114,101,116,117,114,110,32,119,105,116,104,111,117,116,32,118,97,108,117,101,0] /* return without value */, "i8", ALLOC_STATIC); +STRING_TABLE.__str137709=allocate([105,102,0] /* if\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str138710=allocate([119,104,105,108,101,0] /* while\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str139711=allocate([100,111,0] /* do\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str140712=allocate([102,111,114,0] /* for\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str141713=allocate([102,111,114,32,108,111,111,112,115,32,97,114,101,32,110,111,116,32,114,101,99,111,103,110,105,122,101,100,32,105,110,32,116,104,101,32,111,114,105,103,105,110,97,108,32,81,117,97,107,101,32,67,32,115,116,97,110,100,97,114,100,44,32,116,111,32,101,110,97,98,108,101,32,116,114,121,32,97,110,32,97,108,116,101,114,110,97,116,101,32,115,116,97,110,100,97,114,100,32,45,45,115,116,100,61,63,0] /* for loops are not re */, "i8", ALLOC_STATIC); +STRING_TABLE.__str142714=allocate([85,110,101,120,112,101,99,116,101,100,32,107,101,121,119,111,114,100,0] /* Unexpected keyword\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str143715=allocate([115,116,97,116,101,109,101,110,116,32,104,97,115,32,110,111,32,101,102,102,101,99,116,0] /* statement has no eff */, "i8", ALLOC_STATIC); +STRING_TABLE.__str144716=allocate([101,120,112,101,99,116,101,100,32,39,102,111,114,39,32,101,120,112,114,101,115,115,105,111,110,115,32,105,110,32,112,97,114,101,110,116,104,101,115,105,115,0] /* expected 'for' expre */, "i8", ALLOC_STATIC); +STRING_TABLE.__str145717=allocate([101,120,112,101,99,116,101,100,32,39,102,111,114,39,32,105,110,105,116,105,97,108,105,122,101,114,32,97,102,116,101,114,32,111,112,101,110,105,110,103,32,112,97,114,101,110,0] /* expected 'for' initi */, "i8", ALLOC_STATIC); +STRING_TABLE.__str146718=allocate([99,117,114,114,101,110,116,32,115,116,97,110,100,97,114,100,32,100,111,101,115,32,110,111,116,32,97,108,108,111,119,32,118,97,114,105,97,98,108,101,32,100,101,99,108,97,114,97,116,105,111,110,115,32,105,110,32,102,111,114,45,108,111,111,112,32,105,110,105,116,105,97,108,105,122,101,114,115,0] /* current standard doe */, "i8", ALLOC_STATIC); +STRING_TABLE.__str147719=allocate([84,79,68,79,58,32,97,115,115,105,103,110,109,101,110,116,32,111,102,32,110,101,119,32,118,97,114,105,97,98,108,101,115,32,116,111,32,98,101,32,110,111,110,45,99,111,110,115,116,0] /* TODO: assignment of */, "i8", ALLOC_STATIC); +STRING_TABLE.__str148720=allocate([101,120,112,101,99,116,101,100,32,115,101,109,105,99,111,108,111,110,32,97,102,116,101,114,32,102,111,114,45,108,111,111,112,32,105,110,105,116,105,97,108,105,122,101,114,0] /* expected semicolon a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str149721=allocate([101,120,112,101,99,116,101,100,32,102,111,114,45,108,111,111,112,32,99,111,110,100,105,116,105,111,110,0] /* expected for-loop co */, "i8", ALLOC_STATIC); +STRING_TABLE.__str150722=allocate([101,120,112,101,99,116,101,100,32,99,108,111,115,105,110,103,32,112,97,114,101,110,32,97,102,116,101,114,32,39,102,111,114,45,108,111,111,112,39,32,105,110,99,114,101,109,101,110,116,111,114,0] /* expected closing par */, "i8", ALLOC_STATIC); +STRING_TABLE.__str151723=allocate([101,120,112,101,99,116,101,100,32,102,111,114,45,108,111,111,112,32,98,111,100,121,0] /* expected for-loop bo */, "i8", ALLOC_STATIC); +STRING_TABLE.__str152724=allocate([101,120,112,101,99,116,101,100,32,108,111,111,112,32,98,111,100,121,0] /* expected loop body\0 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str153725=allocate([101,120,112,101,99,116,101,100,32,39,119,104,105,108,101,39,32,97,110,100,32,99,111,110,100,105,116,105,111,110,0] /* expected 'while' and */, "i8", ALLOC_STATIC); +STRING_TABLE.__str154=allocate([101,120,112,101,99,116,101,100,32,39,119,104,105,108,101,39,32,99,111,110,100,105,116,105,111,110,32,105,110,32,112,97,114,101,110,116,104,101,115,105,115,0] /* expected 'while' con */, "i8", ALLOC_STATIC); +STRING_TABLE.__str155=allocate([101,120,112,101,99,116,101,100,32,39,119,104,105,108,101,39,32,99,111,110,100,105,116,105,111,110,32,97,102,116,101,114,32,111,112,101,110,105,110,103,32,112,97,114,101,110,0] /* expected 'while' con */, "i8", ALLOC_STATIC); +STRING_TABLE.__str156=allocate([101,120,112,101,99,116,101,100,32,99,108,111,115,105,110,103,32,112,97,114,101,110,32,97,102,116,101,114,32,39,119,104,105,108,101,39,32,99,111,110,100,105,116,105,111,110,0] /* expected closing par */, "i8", ALLOC_STATIC); +STRING_TABLE.__str157=allocate([101,120,112,101,99,116,101,100,32,115,101,109,105,99,111,108,111,110,32,97,102,116,101,114,32,99,111,110,100,105,116,105,111,110,0] /* expected semicolon a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str158=allocate([101,120,112,101,99,116,101,100,32,119,104,105,108,101,45,108,111,111,112,32,98,111,100,121,0] /* expected while-loop */, "i8", ALLOC_STATIC); +STRING_TABLE.__str159=allocate([101,120,112,101,99,116,101,100,32,39,105,102,39,32,99,111,110,100,105,116,105,111,110,32,105,110,32,112,97,114,101,110,116,104,101,115,105,115,0] /* expected 'if' condit */, "i8", ALLOC_STATIC); +STRING_TABLE.__str160=allocate([101,120,112,101,99,116,101,100,32,39,105,102,39,32,99,111,110,100,105,116,105,111,110,32,97,102,116,101,114,32,111,112,101,110,105,110,103,32,112,97,114,101,110,0] /* expected 'if' condit */, "i8", ALLOC_STATIC); +STRING_TABLE.__str161=allocate([101,120,112,101,99,116,101,100,32,99,108,111,115,105,110,103,32,112,97,114,101,110,32,97,102,116,101,114,32,39,105,102,39,32,99,111,110,100,105,116,105,111,110,0] /* expected closing par */, "i8", ALLOC_STATIC); +STRING_TABLE.__str162=allocate([101,120,112,101,99,116,101,100,32,115,116,97,116,101,109,101,110,116,32,102,111,114,32,111,110,45,116,114,117,101,32,98,114,97,110,99,104,32,111,102,32,39,105,102,39,0] /* expected statement f */, "i8", ALLOC_STATIC); +STRING_TABLE.__str163=allocate([101,108,115,101,0] /* else\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str164=allocate([101,120,112,101,99,116,101,100,32,111,110,45,102,97,108,115,101,32,98,114,97,110,99,104,32,97,102,116,101,114,32,39,101,108,115,101,39,0] /* expected on-false br */, "i8", ALLOC_STATIC); +STRING_TABLE.__str165=allocate([101,120,112,101,99,116,101,100,32,102,105,101,108,100,32,112,97,114,97,109,101,116,101,114,32,116,121,112,101,0] /* expected field param */, "i8", ALLOC_STATIC); +STRING_TABLE.__str166=allocate([96,46,46,46,96,32,109,117,115,116,32,98,101,32,116,104,101,32,108,97,115,116,32,112,97,114,97,109,101,116,101,114,32,111,102,32,97,32,118,97,114,105,97,100,105,99,32,102,117,110,99,116,105,111,110,32,100,101,99,108,97,114,97,116,105,111,110,0] /* `...` must be the la */, "i8", ALLOC_STATIC); +STRING_TABLE.__str167=allocate([118,97,114,105,97,100,105,99,32,102,117,110,99,116,105,111,110,115,32,97,114,101,32,110,111,116,32,97,118,97,105,108,97,98,108,101,32,105,110,32,116,104,105,115,32,115,116,97,110,100,97,114,100,0] /* variadic functions a */, "i8", ALLOC_STATIC); +STRING_TABLE.__str168=allocate([79,117,116,32,111,102,32,109,101,109,111,114,121,32,119,104,105,108,101,32,112,97,114,115,105,110,103,32,116,121,112,101,110,97,109,101,0] /* Out of memory while */, "i8", ALLOC_STATIC); +STRING_TABLE.__str169=allocate([85,110,101,120,112,101,99,116,101,100,32,116,111,107,101,110,0] /* Unexpected token\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str170=allocate([109,111,114,101,32,116,104,97,110,32,56,32,112,97,114,97,109,101,116,101,114,115,32,97,114,101,32,99,117,114,114,101,110,116,108,121,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0] /* more than 8 paramete */, "i8", ALLOC_STATIC); +STRING_TABLE.__str171=allocate([60,117,110,110,97,109,101,100,62,0] /* _unnamed_\00 */, "i8", ALLOC_STATIC); +_mem_ab=allocate(8, "i8", ALLOC_STATIC); +_mem_db=allocate(8, "i8", ALLOC_STATIC); +_mem_at=allocate(8, "i8", ALLOC_STATIC); +_mem_dt=allocate(8, "i8", ALLOC_STATIC); +_mem_start=allocate(4, "i8", ALLOC_STATIC); +STRING_TABLE.__str736=allocate([77,69,77,0] /* MEM\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1737=allocate([97,108,108,111,99,97,116,105,111,110,58,32,32,32,37,32,56,117,32,40,98,121,116,101,115,41,32,97,100,100,114,101,115,115,32,48,120,37,48,56,88,32,64,32,37,115,58,37,117,10,0] /* allocation: % 8u ( */, "i8", ALLOC_STATIC); +STRING_TABLE.__str2738=allocate([114,101,108,101,97,115,101,100,58,32,32,32,32,32,37,32,56,117,32,40,98,121,116,101,115,41,32,97,100,100,114,101,115,115,32,48,120,37,48,56,88,32,64,32,37,115,58,37,117,10,0] /* released: % 8u ( */, "i8", ALLOC_STATIC); +STRING_TABLE.__str4740=allocate([108,111,115,116,58,32,32,32,32,32,32,32,37,32,56,117,32,40,98,121,116,101,115,41,32,97,116,32,37,115,58,37,117,10,0] /* lost: % 8u (by */, "i8", ALLOC_STATIC); +STRING_TABLE.__str5741=allocate([77,101,109,111,114,121,32,105,110,102,111,114,109,97,116,105,111,110,58,10,32,32,32,32,32,32,32,32,84,111,116,97,108,32,97,108,108,111,99,97,116,105,111,110,115,58,32,32,32,37,108,108,117,10,32,32,32,32,32,32,32,32,84,111,116,97,108,32,100,101,97,108,108,111,99,97,116,105,111,110,115,58,32,37,108,108,117,10,32,32,32,32,32,32,32,32,84,111,116,97,108,32,97,108,108,111,99,97,116,101,100,58,32,32,32,32,32,37,108,108,117,32,40,98,121,116,101,115,41,10,32,32,32,32,32,32,32,32,84,111,116,97,108,32,100,101,97,108,108,111,99,97,116,101,100,58,32,32,32,37,108,108,117,32,40,98,121,116,101,115,41,10,32,32,32,32,32,32,32,32,76,101,97,107,115,32,102,111,117,110,100,58,32,32,32,32,32,32,32,32,32,108,111,115,116,32,37,108,108,117,32,40,98,121,116,101,115,41,32,105,110,32,37,100,32,97,108,108,111,99,97,116,105,111,110,115,10,0] /* Memory information:\ */, "i8", ALLOC_STATIC); +STRING_TABLE.__str6742=allocate([117,116,105,108,46,99,0] /* util.c\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7743=allocate([68,69,66,85,71,58,32,0] /* DEBUG: \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str8744=allocate([37,115,0] /* %s\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str9745=allocate([93,32,0] /* ] \00 */, "i8", ALLOC_STATIC); +_util_crc16_table=allocate([0, 0, 4129, 0, 8258, 0, 12387, 0, 16516, 0, 20645, 0, 24774, 0, 28903, 0, -32504, 0, -28375, 0, -24246, 0, -20117, 0, -15988, 0, -11859, 0, -7730, 0, -3601, 0, 4657, 0, 528, 0, 12915, 0, 8786, 0, 21173, 0, 17044, 0, 29431, 0, 25302, 0, -27847, 0, -31976, 0, -19589, 0, -23718, 0, -11331, 0, -15460, 0, -3073, 0, -7202, 0, 9314, 0, 13379, 0, 1056, 0, 5121, 0, 25830, 0, 29895, 0, 17572, 0, 21637, 0, -23190, 0, -19125, 0, -31448, 0, -27383, 0, -6674, 0, -2609, 0, -14932, 0, -10867, 0, 13907, 0, 9842, 0, 5649, 0, 1584, 0, 30423, 0, 26358, 0, 22165, 0, 18100, 0, -18597, 0, -22662, 0, -26855, 0, -30920, 0, -2081, 0, -6146, 0, -10339, 0, -14404, 0, 18628, 0, 22757, 0, 26758, 0, 30887, 0, 2112, 0, 6241, 0, 10242, 0, 14371, 0, -13876, 0, -9747, 0, -5746, 0, -1617, 0, -30392, 0, -26263, 0, -22262, 0, -18133, 0, 23285, 0, 19156, 0, 31415, 0, 27286, 0, 6769, 0, 2640, 0, 14899, 0, 10770, 0, -9219, 0, -13348, 0, -1089, 0, -5218, 0, -25735, 0, -29864, 0, -17605, 0, -21734, 0, 27814, 0, 31879, 0, 19684, 0, 23749, 0, 11298, 0, 15363, 0, 3168, 0, 7233, 0, -4690, 0, -625, 0, -12820, 0, -8755, 0, -21206, 0, -17141, 0, -29336, 0, -25271, 0, 32407, 0, 28342, 0, 24277, 0, 20212, 0, 15891, 0, 11826, 0, 7761, 0, 3696, 0, -97, 0, -4162, 0, -8227, 0, -12292, 0, -16613, 0, -20678, 0, -24743, 0, -28808, 0, -28280, 0, -32343, 0, -20022, 0, -24085, 0, -12020, 0, -16083, 0, -3762, 0, -7825, 0, 4224, 0, 161, 0, 12482, 0, 8419, 0, 20484, 0, 16421, 0, 28742, 0, 24679, 0, -31815, 0, -27752, 0, -23557, 0, -19494, 0, -15555, 0, -11492, 0, -7297, 0, -3234, 0, 689, 0, 4752, 0, 8947, 0, 13010, 0, 16949, 0, 21012, 0, 25207, 0, 29270, 0, -18966, 0, -23093, 0, -27224, 0, -31351, 0, -2706, 0, -6833, 0, -10964, 0, -15091, 0, 13538, 0, 9411, 0, 5280, 0, 1153, 0, 29798, 0, 25671, 0, 21540, 0, 17413, 0, -22565, 0, -18438, 0, -30823, 0, -26696, 0, -6305, 0, -2178, 0, -14563, 0, -10436, 0, 9939, 0, 14066, 0, 1681, 0, 5808, 0, 26199, 0, 30326, 0, 17941, 0, 22068, 0, -9908, 0, -13971, 0, -1778, 0, -5841, 0, -26168, 0, -30231, 0, -18038, 0, -22101, 0, 22596, 0, 18533, 0, 30726, 0, 26663, 0, 6336, 0, 2273, 0, 14466, 0, 10403, 0, -13443, 0, -9380, 0, -5313, 0, -1250, 0, -29703, 0, -25640, 0, -21573, 0, -17510, 0, 19061, 0, 23124, 0, 27191, 0, 31254, 0, 2801, 0, 6864, 0, 10931, 0, 14994, 0, -722, 0, -4849, 0, -8852, 0, -12979, 0, -16982, 0, -21109, 0, -25112, 0, -29239, 0, 31782, 0, 27655, 0, 23652, 0, 19525, 0, 15522, 0, 11395, 0, 7392, 0, 3265, 0, -4321, 0, -194, 0, -12451, 0, -8324, 0, -20581, 0, -16454, 0, -28711, 0, -24584, 0, 28183, 0, 32310, 0, 20053, 0, 24180, 0, 11923, 0, 16050, 0, 3793, 0, 7920, 0], ["i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0,"i16",0], ALLOC_STATIC); +__gm_=allocate(468, "i8", ALLOC_STATIC); +_mparams=allocate(24, "i8", ALLOC_STATIC); +HEAP32[((_asm_instr)>>2)]=((STRING_TABLE.__str42)|0); +HEAP32[(((_asm_instr)+(12))>>2)]=((STRING_TABLE.__str43)|0); +HEAP32[(((_asm_instr)+(24))>>2)]=((STRING_TABLE.__str44)|0); +HEAP32[(((_asm_instr)+(36))>>2)]=((STRING_TABLE.__str45)|0); +HEAP32[(((_asm_instr)+(48))>>2)]=((STRING_TABLE.__str46)|0); +HEAP32[(((_asm_instr)+(60))>>2)]=((STRING_TABLE.__str47)|0); +HEAP32[(((_asm_instr)+(72))>>2)]=((STRING_TABLE.__str48)|0); +HEAP32[(((_asm_instr)+(84))>>2)]=((STRING_TABLE.__str49)|0); +HEAP32[(((_asm_instr)+(96))>>2)]=((STRING_TABLE.__str50)|0); +HEAP32[(((_asm_instr)+(108))>>2)]=((STRING_TABLE.__str51)|0); +HEAP32[(((_asm_instr)+(120))>>2)]=((STRING_TABLE.__str52)|0); +HEAP32[(((_asm_instr)+(132))>>2)]=((STRING_TABLE.__str53)|0); +HEAP32[(((_asm_instr)+(144))>>2)]=((STRING_TABLE.__str54)|0); +HEAP32[(((_asm_instr)+(156))>>2)]=((STRING_TABLE.__str55)|0); +HEAP32[(((_asm_instr)+(168))>>2)]=((STRING_TABLE.__str56)|0); +HEAP32[(((_asm_instr)+(180))>>2)]=((STRING_TABLE.__str57)|0); +HEAP32[(((_asm_instr)+(192))>>2)]=((STRING_TABLE.__str58)|0); +HEAP32[(((_asm_instr)+(204))>>2)]=((STRING_TABLE.__str59)|0); +HEAP32[(((_asm_instr)+(216))>>2)]=((STRING_TABLE.__str60)|0); +HEAP32[(((_asm_instr)+(228))>>2)]=((STRING_TABLE.__str61)|0); +HEAP32[(((_asm_instr)+(240))>>2)]=((STRING_TABLE.__str62)|0); +HEAP32[(((_asm_instr)+(252))>>2)]=((STRING_TABLE.__str63)|0); +HEAP32[(((_asm_instr)+(264))>>2)]=((STRING_TABLE.__str64)|0); +HEAP32[(((_asm_instr)+(276))>>2)]=((STRING_TABLE.__str65)|0); +HEAP32[(((_asm_instr)+(288))>>2)]=((STRING_TABLE.__str66)|0); +HEAP32[(((_asm_instr)+(300))>>2)]=((STRING_TABLE.__str67)|0); +HEAP32[(((_asm_instr)+(312))>>2)]=((STRING_TABLE.__str68)|0); +HEAP32[(((_asm_instr)+(324))>>2)]=((STRING_TABLE.__str69)|0); +HEAP32[(((_asm_instr)+(336))>>2)]=((STRING_TABLE.__str70)|0); +HEAP32[(((_asm_instr)+(348))>>2)]=((STRING_TABLE.__str71)|0); +HEAP32[(((_asm_instr)+(360))>>2)]=((STRING_TABLE.__str24)|0); +HEAP32[(((_asm_instr)+(372))>>2)]=((STRING_TABLE.__str72)|0); +HEAP32[(((_asm_instr)+(384))>>2)]=((STRING_TABLE.__str73)|0); +HEAP32[(((_asm_instr)+(396))>>2)]=((STRING_TABLE.__str74)|0); +HEAP32[(((_asm_instr)+(408))>>2)]=((STRING_TABLE.__str75)|0); +HEAP32[(((_asm_instr)+(420))>>2)]=((STRING_TABLE.__str76)|0); +HEAP32[(((_asm_instr)+(432))>>2)]=((STRING_TABLE.__str77)|0); +HEAP32[(((_asm_instr)+(444))>>2)]=((STRING_TABLE.__str78)|0); +HEAP32[(((_asm_instr)+(456))>>2)]=((STRING_TABLE.__str79)|0); +HEAP32[(((_asm_instr)+(468))>>2)]=((STRING_TABLE.__str80)|0); +HEAP32[(((_asm_instr)+(480))>>2)]=((STRING_TABLE.__str81)|0); +HEAP32[(((_asm_instr)+(492))>>2)]=((STRING_TABLE.__str82)|0); +HEAP32[(((_asm_instr)+(504))>>2)]=((STRING_TABLE.__str83)|0); +HEAP32[(((_asm_instr)+(516))>>2)]=((STRING_TABLE.__str84)|0); +HEAP32[(((_asm_instr)+(528))>>2)]=((STRING_TABLE.__str85)|0); +HEAP32[(((_asm_instr)+(540))>>2)]=((STRING_TABLE.__str86)|0); +HEAP32[(((_asm_instr)+(552))>>2)]=((STRING_TABLE.__str87)|0); +HEAP32[(((_asm_instr)+(564))>>2)]=((STRING_TABLE.__str88)|0); +HEAP32[(((_asm_instr)+(576))>>2)]=((STRING_TABLE.__str89)|0); +HEAP32[(((_asm_instr)+(588))>>2)]=((STRING_TABLE.__str90)|0); +HEAP32[(((_asm_instr)+(600))>>2)]=((STRING_TABLE.__str91)|0); +HEAP32[(((_asm_instr)+(612))>>2)]=((STRING_TABLE.__str92)|0); +HEAP32[(((_asm_instr)+(624))>>2)]=((STRING_TABLE.__str93)|0); +HEAP32[(((_asm_instr)+(636))>>2)]=((STRING_TABLE.__str94)|0); +HEAP32[(((_asm_instr)+(648))>>2)]=((STRING_TABLE.__str95)|0); +HEAP32[(((_asm_instr)+(660))>>2)]=((STRING_TABLE.__str96)|0); +HEAP32[(((_asm_instr)+(672))>>2)]=((STRING_TABLE.__str97)|0); +HEAP32[(((_asm_instr)+(684))>>2)]=((STRING_TABLE.__str98)|0); +HEAP32[(((_asm_instr)+(696))>>2)]=((STRING_TABLE.__str99)|0); +HEAP32[(((_asm_instr)+(708))>>2)]=((STRING_TABLE.__str100)|0); +HEAP32[(((_asm_instr)+(720))>>2)]=((STRING_TABLE.__str101)|0); +HEAP32[(((_asm_instr)+(732))>>2)]=((STRING_TABLE.__str102)|0); +HEAP32[(((_asm_instr)+(744))>>2)]=((STRING_TABLE.__str103)|0); +HEAP32[(((_asm_instr)+(756))>>2)]=((STRING_TABLE.__str104)|0); +HEAP32[(((_asm_instr)+(768))>>2)]=((STRING_TABLE.__str105)|0); +HEAP32[(((_asm_instr)+(780))>>2)]=((STRING_TABLE.__str106)|0); +HEAP32[(((_asm_instr)+(792))>>2)]=((STRING_TABLE.__str107)|0); +HEAP32[((_asm_instr138)>>2)]=((STRING_TABLE.__str27140)|0); +HEAP32[(((_asm_instr138)+(12))>>2)]=((STRING_TABLE.__str28141)|0); +HEAP32[(((_asm_instr138)+(24))>>2)]=((STRING_TABLE.__str29142)|0); +HEAP32[(((_asm_instr138)+(36))>>2)]=((STRING_TABLE.__str30143)|0); +HEAP32[(((_asm_instr138)+(48))>>2)]=((STRING_TABLE.__str31144)|0); +HEAP32[(((_asm_instr138)+(60))>>2)]=((STRING_TABLE.__str32145)|0); +HEAP32[(((_asm_instr138)+(72))>>2)]=((STRING_TABLE.__str33146)|0); +HEAP32[(((_asm_instr138)+(84))>>2)]=((STRING_TABLE.__str34147)|0); +HEAP32[(((_asm_instr138)+(96))>>2)]=((STRING_TABLE.__str35148)|0); +HEAP32[(((_asm_instr138)+(108))>>2)]=((STRING_TABLE.__str36149)|0); +HEAP32[(((_asm_instr138)+(120))>>2)]=((STRING_TABLE.__str37150)|0); +HEAP32[(((_asm_instr138)+(132))>>2)]=((STRING_TABLE.__str38151)|0); +HEAP32[(((_asm_instr138)+(144))>>2)]=((STRING_TABLE.__str39152)|0); +HEAP32[(((_asm_instr138)+(156))>>2)]=((STRING_TABLE.__str40153)|0); +HEAP32[(((_asm_instr138)+(168))>>2)]=((STRING_TABLE.__str41154)|0); +HEAP32[(((_asm_instr138)+(180))>>2)]=((STRING_TABLE.__str42155)|0); +HEAP32[(((_asm_instr138)+(192))>>2)]=((STRING_TABLE.__str43156)|0); +HEAP32[(((_asm_instr138)+(204))>>2)]=((STRING_TABLE.__str44157)|0); +HEAP32[(((_asm_instr138)+(216))>>2)]=((STRING_TABLE.__str45158)|0); +HEAP32[(((_asm_instr138)+(228))>>2)]=((STRING_TABLE.__str46159)|0); +HEAP32[(((_asm_instr138)+(240))>>2)]=((STRING_TABLE.__str47160)|0); +HEAP32[(((_asm_instr138)+(252))>>2)]=((STRING_TABLE.__str48161)|0); +HEAP32[(((_asm_instr138)+(264))>>2)]=((STRING_TABLE.__str49162)|0); +HEAP32[(((_asm_instr138)+(276))>>2)]=((STRING_TABLE.__str50163)|0); +HEAP32[(((_asm_instr138)+(288))>>2)]=((STRING_TABLE.__str51164)|0); +HEAP32[(((_asm_instr138)+(300))>>2)]=((STRING_TABLE.__str52165)|0); +HEAP32[(((_asm_instr138)+(312))>>2)]=((STRING_TABLE.__str53166)|0); +HEAP32[(((_asm_instr138)+(324))>>2)]=((STRING_TABLE.__str54167)|0); +HEAP32[(((_asm_instr138)+(336))>>2)]=((STRING_TABLE.__str55168)|0); +HEAP32[(((_asm_instr138)+(348))>>2)]=((STRING_TABLE.__str56169)|0); +HEAP32[(((_asm_instr138)+(360))>>2)]=((STRING_TABLE.__str57170)|0); +HEAP32[(((_asm_instr138)+(372))>>2)]=((STRING_TABLE.__str58171)|0); +HEAP32[(((_asm_instr138)+(384))>>2)]=((STRING_TABLE.__str59172)|0); +HEAP32[(((_asm_instr138)+(396))>>2)]=((STRING_TABLE.__str60173)|0); +HEAP32[(((_asm_instr138)+(408))>>2)]=((STRING_TABLE.__str61174)|0); +HEAP32[(((_asm_instr138)+(420))>>2)]=((STRING_TABLE.__str62175)|0); +HEAP32[(((_asm_instr138)+(432))>>2)]=((STRING_TABLE.__str63176)|0); +HEAP32[(((_asm_instr138)+(444))>>2)]=((STRING_TABLE.__str64177)|0); +HEAP32[(((_asm_instr138)+(456))>>2)]=((STRING_TABLE.__str65178)|0); +HEAP32[(((_asm_instr138)+(468))>>2)]=((STRING_TABLE.__str66179)|0); +HEAP32[(((_asm_instr138)+(480))>>2)]=((STRING_TABLE.__str67180)|0); +HEAP32[(((_asm_instr138)+(492))>>2)]=((STRING_TABLE.__str68181)|0); +HEAP32[(((_asm_instr138)+(504))>>2)]=((STRING_TABLE.__str69182)|0); +HEAP32[(((_asm_instr138)+(516))>>2)]=((STRING_TABLE.__str70183)|0); +HEAP32[(((_asm_instr138)+(528))>>2)]=((STRING_TABLE.__str71184)|0); +HEAP32[(((_asm_instr138)+(540))>>2)]=((STRING_TABLE.__str72185)|0); +HEAP32[(((_asm_instr138)+(552))>>2)]=((STRING_TABLE.__str73186)|0); +HEAP32[(((_asm_instr138)+(564))>>2)]=((STRING_TABLE.__str74187)|0); +HEAP32[(((_asm_instr138)+(576))>>2)]=((STRING_TABLE.__str75188)|0); +HEAP32[(((_asm_instr138)+(588))>>2)]=((STRING_TABLE.__str76189)|0); +HEAP32[(((_asm_instr138)+(600))>>2)]=((STRING_TABLE.__str77190)|0); +HEAP32[(((_asm_instr138)+(612))>>2)]=((STRING_TABLE.__str78191)|0); +HEAP32[(((_asm_instr138)+(624))>>2)]=((STRING_TABLE.__str79192)|0); +HEAP32[(((_asm_instr138)+(636))>>2)]=((STRING_TABLE.__str80193)|0); +HEAP32[(((_asm_instr138)+(648))>>2)]=((STRING_TABLE.__str81194)|0); +HEAP32[(((_asm_instr138)+(660))>>2)]=((STRING_TABLE.__str82195)|0); +HEAP32[(((_asm_instr138)+(672))>>2)]=((STRING_TABLE.__str83196)|0); +HEAP32[(((_asm_instr138)+(684))>>2)]=((STRING_TABLE.__str84197)|0); +HEAP32[(((_asm_instr138)+(696))>>2)]=((STRING_TABLE.__str85198)|0); +HEAP32[(((_asm_instr138)+(708))>>2)]=((STRING_TABLE.__str86199)|0); +HEAP32[(((_asm_instr138)+(720))>>2)]=((STRING_TABLE.__str87200)|0); +HEAP32[(((_asm_instr138)+(732))>>2)]=((STRING_TABLE.__str88201)|0); +HEAP32[(((_asm_instr138)+(744))>>2)]=((STRING_TABLE.__str89202)|0); +HEAP32[(((_asm_instr138)+(756))>>2)]=((STRING_TABLE.__str90203)|0); +HEAP32[(((_asm_instr138)+(768))>>2)]=((STRING_TABLE.__str91204)|0); +HEAP32[(((_asm_instr138)+(780))>>2)]=((STRING_TABLE.__str92205)|0); +HEAP32[(((_asm_instr138)+(792))>>2)]=((STRING_TABLE.__str93206)|0); +HEAP32[((_type_name)>>2)]=((STRING_TABLE.__str211)|0); +HEAP32[(((_type_name)+(4))>>2)]=((STRING_TABLE.__str1212)|0); +HEAP32[(((_type_name)+(8))>>2)]=((STRING_TABLE.__str2213)|0); +HEAP32[(((_type_name)+(12))>>2)]=((STRING_TABLE.__str3214)|0); +HEAP32[(((_type_name)+(16))>>2)]=((STRING_TABLE.__str4215)|0); +HEAP32[(((_type_name)+(20))>>2)]=((STRING_TABLE.__str5216)|0); +HEAP32[(((_type_name)+(24))>>2)]=((STRING_TABLE.__str6217)|0); +HEAP32[(((_type_name)+(28))>>2)]=((STRING_TABLE.__str7218)|0); +HEAP32[(((_type_name)+(32))>>2)]=((STRING_TABLE.__str8219)|0); +HEAP32[((_asm_instr231)>>2)]=((STRING_TABLE.__str86300)|0); +HEAP32[(((_asm_instr231)+(12))>>2)]=((STRING_TABLE.__str87301)|0); +HEAP32[(((_asm_instr231)+(24))>>2)]=((STRING_TABLE.__str88302)|0); +HEAP32[(((_asm_instr231)+(36))>>2)]=((STRING_TABLE.__str89303)|0); +HEAP32[(((_asm_instr231)+(48))>>2)]=((STRING_TABLE.__str90304)|0); +HEAP32[(((_asm_instr231)+(60))>>2)]=((STRING_TABLE.__str91305)|0); +HEAP32[(((_asm_instr231)+(72))>>2)]=((STRING_TABLE.__str92306)|0); +HEAP32[(((_asm_instr231)+(84))>>2)]=((STRING_TABLE.__str93307)|0); +HEAP32[(((_asm_instr231)+(96))>>2)]=((STRING_TABLE.__str94308)|0); +HEAP32[(((_asm_instr231)+(108))>>2)]=((STRING_TABLE.__str95309)|0); +HEAP32[(((_asm_instr231)+(120))>>2)]=((STRING_TABLE.__str96310)|0); +HEAP32[(((_asm_instr231)+(132))>>2)]=((STRING_TABLE.__str97311)|0); +HEAP32[(((_asm_instr231)+(144))>>2)]=((STRING_TABLE.__str98312)|0); +HEAP32[(((_asm_instr231)+(156))>>2)]=((STRING_TABLE.__str99313)|0); +HEAP32[(((_asm_instr231)+(168))>>2)]=((STRING_TABLE.__str100314)|0); +HEAP32[(((_asm_instr231)+(180))>>2)]=((STRING_TABLE.__str101315)|0); +HEAP32[(((_asm_instr231)+(192))>>2)]=((STRING_TABLE.__str102316)|0); +HEAP32[(((_asm_instr231)+(204))>>2)]=((STRING_TABLE.__str103317)|0); +HEAP32[(((_asm_instr231)+(216))>>2)]=((STRING_TABLE.__str104318)|0); +HEAP32[(((_asm_instr231)+(228))>>2)]=((STRING_TABLE.__str105319)|0); +HEAP32[(((_asm_instr231)+(240))>>2)]=((STRING_TABLE.__str106320)|0); +HEAP32[(((_asm_instr231)+(252))>>2)]=((STRING_TABLE.__str107321)|0); +HEAP32[(((_asm_instr231)+(264))>>2)]=((STRING_TABLE.__str108322)|0); +HEAP32[(((_asm_instr231)+(276))>>2)]=((STRING_TABLE.__str109323)|0); +HEAP32[(((_asm_instr231)+(288))>>2)]=((STRING_TABLE.__str110324)|0); +HEAP32[(((_asm_instr231)+(300))>>2)]=((STRING_TABLE.__str111325)|0); +HEAP32[(((_asm_instr231)+(312))>>2)]=((STRING_TABLE.__str112326)|0); +HEAP32[(((_asm_instr231)+(324))>>2)]=((STRING_TABLE.__str113)|0); +HEAP32[(((_asm_instr231)+(336))>>2)]=((STRING_TABLE.__str114)|0); +HEAP32[(((_asm_instr231)+(348))>>2)]=((STRING_TABLE.__str115)|0); +HEAP32[(((_asm_instr231)+(360))>>2)]=((STRING_TABLE.__str116)|0); +HEAP32[(((_asm_instr231)+(372))>>2)]=((STRING_TABLE.__str117)|0); +HEAP32[(((_asm_instr231)+(384))>>2)]=((STRING_TABLE.__str118)|0); +HEAP32[(((_asm_instr231)+(396))>>2)]=((STRING_TABLE.__str119)|0); +HEAP32[(((_asm_instr231)+(408))>>2)]=((STRING_TABLE.__str120)|0); +HEAP32[(((_asm_instr231)+(420))>>2)]=((STRING_TABLE.__str121)|0); +HEAP32[(((_asm_instr231)+(432))>>2)]=((STRING_TABLE.__str122)|0); +HEAP32[(((_asm_instr231)+(444))>>2)]=((STRING_TABLE.__str123)|0); +HEAP32[(((_asm_instr231)+(456))>>2)]=((STRING_TABLE.__str124)|0); +HEAP32[(((_asm_instr231)+(468))>>2)]=((STRING_TABLE.__str125)|0); +HEAP32[(((_asm_instr231)+(480))>>2)]=((STRING_TABLE.__str126)|0); +HEAP32[(((_asm_instr231)+(492))>>2)]=((STRING_TABLE.__str127)|0); +HEAP32[(((_asm_instr231)+(504))>>2)]=((STRING_TABLE.__str128)|0); +HEAP32[(((_asm_instr231)+(516))>>2)]=((STRING_TABLE.__str129)|0); +HEAP32[(((_asm_instr231)+(528))>>2)]=((STRING_TABLE.__str130)|0); +HEAP32[(((_asm_instr231)+(540))>>2)]=((STRING_TABLE.__str131)|0); +HEAP32[(((_asm_instr231)+(552))>>2)]=((STRING_TABLE.__str132)|0); +HEAP32[(((_asm_instr231)+(564))>>2)]=((STRING_TABLE.__str133)|0); +HEAP32[(((_asm_instr231)+(576))>>2)]=((STRING_TABLE.__str134)|0); +HEAP32[(((_asm_instr231)+(588))>>2)]=((STRING_TABLE.__str135)|0); +HEAP32[(((_asm_instr231)+(600))>>2)]=((STRING_TABLE.__str136)|0); +HEAP32[(((_asm_instr231)+(612))>>2)]=((STRING_TABLE.__str137)|0); +HEAP32[(((_asm_instr231)+(624))>>2)]=((STRING_TABLE.__str138)|0); +HEAP32[(((_asm_instr231)+(636))>>2)]=((STRING_TABLE.__str139)|0); +HEAP32[(((_asm_instr231)+(648))>>2)]=((STRING_TABLE.__str140)|0); +HEAP32[(((_asm_instr231)+(660))>>2)]=((STRING_TABLE.__str141)|0); +HEAP32[(((_asm_instr231)+(672))>>2)]=((STRING_TABLE.__str142)|0); +HEAP32[(((_asm_instr231)+(684))>>2)]=((STRING_TABLE.__str143)|0); +HEAP32[(((_asm_instr231)+(696))>>2)]=((STRING_TABLE.__str144)|0); +HEAP32[(((_asm_instr231)+(708))>>2)]=((STRING_TABLE.__str145)|0); +HEAP32[(((_asm_instr231)+(720))>>2)]=((STRING_TABLE.__str146)|0); +HEAP32[(((_asm_instr231)+(732))>>2)]=((STRING_TABLE.__str147)|0); +HEAP32[(((_asm_instr231)+(744))>>2)]=((STRING_TABLE.__str148)|0); +HEAP32[(((_asm_instr231)+(756))>>2)]=((STRING_TABLE.__str149)|0); +HEAP32[(((_asm_instr231)+(768))>>2)]=((STRING_TABLE.__str150)|0); +HEAP32[(((_asm_instr231)+(780))>>2)]=((STRING_TABLE.__str151)|0); +HEAP32[(((_asm_instr231)+(792))>>2)]=((STRING_TABLE.__str152)|0); +HEAP32[((_opts_output)>>2)]=((STRING_TABLE.__str437)|0); +HEAP32[((_c_operators)>>2)]=((STRING_TABLE.__str41494)|0); +HEAP32[(((_c_operators)+(24))>>2)]=((STRING_TABLE.__str67520)|0); +HEAP32[(((_c_operators)+(48))>>2)]=((STRING_TABLE.__str68521)|0); +HEAP32[(((_c_operators)+(72))>>2)]=((STRING_TABLE.__str42495)|0); +HEAP32[(((_c_operators)+(96))>>2)]=((STRING_TABLE.__str41494)|0); +HEAP32[(((_c_operators)+(120))>>2)]=((STRING_TABLE.__str43496)|0); +HEAP32[(((_c_operators)+(144))>>2)]=((STRING_TABLE.__str69522)|0); +HEAP32[(((_c_operators)+(168))>>2)]=((STRING_TABLE.__str44497)|0); +HEAP32[(((_c_operators)+(192))>>2)]=((STRING_TABLE.__str45498)|0); +HEAP32[(((_c_operators)+(216))>>2)]=((STRING_TABLE.__str67520)|0); +HEAP32[(((_c_operators)+(240))>>2)]=((STRING_TABLE.__str68521)|0); +HEAP32[(((_c_operators)+(264))>>2)]=((STRING_TABLE.__str46499)|0); +HEAP32[(((_c_operators)+(288))>>2)]=((STRING_TABLE.__str47500)|0); +HEAP32[(((_c_operators)+(312))>>2)]=((STRING_TABLE.__str70523)|0); +HEAP32[(((_c_operators)+(336))>>2)]=((STRING_TABLE.__str44497)|0); +HEAP32[(((_c_operators)+(360))>>2)]=((STRING_TABLE.__str45498)|0); +HEAP32[(((_c_operators)+(384))>>2)]=((STRING_TABLE.__str71524)|0); +HEAP32[(((_c_operators)+(408))>>2)]=((STRING_TABLE.__str72525)|0); +HEAP32[(((_c_operators)+(432))>>2)]=((STRING_TABLE.__str50503)|0); +HEAP32[(((_c_operators)+(456))>>2)]=((STRING_TABLE.__str51504)|0); +HEAP32[(((_c_operators)+(480))>>2)]=((STRING_TABLE.__str52505)|0); +HEAP32[(((_c_operators)+(504))>>2)]=((STRING_TABLE.__str53506)|0); +HEAP32[(((_c_operators)+(528))>>2)]=((STRING_TABLE.__str54507)|0); +HEAP32[(((_c_operators)+(552))>>2)]=((STRING_TABLE.__str55508)|0); +HEAP32[(((_c_operators)+(576))>>2)]=((STRING_TABLE.__str48501)|0); +HEAP32[(((_c_operators)+(600))>>2)]=((STRING_TABLE.__str73526)|0); +HEAP32[(((_c_operators)+(624))>>2)]=((STRING_TABLE.__str49502)|0); +HEAP32[(((_c_operators)+(648))>>2)]=((STRING_TABLE.__str64517)|0); +HEAP32[(((_c_operators)+(672))>>2)]=((STRING_TABLE.__str65518)|0); +HEAP32[(((_c_operators)+(696))>>2)]=((STRING_TABLE.__str74527)|0); +HEAP32[(((_c_operators)+(720))>>2)]=((STRING_TABLE.__str56509)|0); +HEAP32[(((_c_operators)+(744))>>2)]=((STRING_TABLE.__str57510)|0); +HEAP32[(((_c_operators)+(768))>>2)]=((STRING_TABLE.__str58511)|0); +HEAP32[(((_c_operators)+(792))>>2)]=((STRING_TABLE.__str59512)|0); +HEAP32[(((_c_operators)+(816))>>2)]=((STRING_TABLE.__str60513)|0); +HEAP32[(((_c_operators)+(840))>>2)]=((STRING_TABLE.__str61514)|0); +HEAP32[(((_c_operators)+(864))>>2)]=((STRING_TABLE.__str75528)|0); +HEAP32[(((_c_operators)+(888))>>2)]=((STRING_TABLE.__str76529)|0); +HEAP32[(((_c_operators)+(912))>>2)]=((STRING_TABLE.__str62515)|0); +HEAP32[(((_c_operators)+(936))>>2)]=((STRING_TABLE.__str77530)|0); +HEAP32[(((_c_operators)+(960))>>2)]=((STRING_TABLE.__str63516)|0); +HEAP32[(((_c_operators)+(984))>>2)]=((STRING_TABLE.__str66519)|0); +HEAP32[((_qcc_operators)>>2)]=((STRING_TABLE.__str41494)|0); +HEAP32[(((_qcc_operators)+(24))>>2)]=((STRING_TABLE.__str42495)|0); +HEAP32[(((_qcc_operators)+(48))>>2)]=((STRING_TABLE.__str41494)|0); +HEAP32[(((_qcc_operators)+(72))>>2)]=((STRING_TABLE.__str43496)|0); +HEAP32[(((_qcc_operators)+(96))>>2)]=((STRING_TABLE.__str44497)|0); +HEAP32[(((_qcc_operators)+(120))>>2)]=((STRING_TABLE.__str45498)|0); +HEAP32[(((_qcc_operators)+(144))>>2)]=((STRING_TABLE.__str46499)|0); +HEAP32[(((_qcc_operators)+(168))>>2)]=((STRING_TABLE.__str47500)|0); +HEAP32[(((_qcc_operators)+(192))>>2)]=((STRING_TABLE.__str48501)|0); +HEAP32[(((_qcc_operators)+(216))>>2)]=((STRING_TABLE.__str49502)|0); +HEAP32[(((_qcc_operators)+(240))>>2)]=((STRING_TABLE.__str44497)|0); +HEAP32[(((_qcc_operators)+(264))>>2)]=((STRING_TABLE.__str45498)|0); +HEAP32[(((_qcc_operators)+(288))>>2)]=((STRING_TABLE.__str50503)|0); +HEAP32[(((_qcc_operators)+(312))>>2)]=((STRING_TABLE.__str51504)|0); +HEAP32[(((_qcc_operators)+(336))>>2)]=((STRING_TABLE.__str52505)|0); +HEAP32[(((_qcc_operators)+(360))>>2)]=((STRING_TABLE.__str53506)|0); +HEAP32[(((_qcc_operators)+(384))>>2)]=((STRING_TABLE.__str54507)|0); +HEAP32[(((_qcc_operators)+(408))>>2)]=((STRING_TABLE.__str55508)|0); +HEAP32[(((_qcc_operators)+(432))>>2)]=((STRING_TABLE.__str56509)|0); +HEAP32[(((_qcc_operators)+(456))>>2)]=((STRING_TABLE.__str57510)|0); +HEAP32[(((_qcc_operators)+(480))>>2)]=((STRING_TABLE.__str58511)|0); +HEAP32[(((_qcc_operators)+(504))>>2)]=((STRING_TABLE.__str59512)|0); +HEAP32[(((_qcc_operators)+(528))>>2)]=((STRING_TABLE.__str60513)|0); +HEAP32[(((_qcc_operators)+(552))>>2)]=((STRING_TABLE.__str61514)|0); +HEAP32[(((_qcc_operators)+(576))>>2)]=((STRING_TABLE.__str62515)|0); +HEAP32[(((_qcc_operators)+(600))>>2)]=((STRING_TABLE.__str63516)|0); +HEAP32[(((_qcc_operators)+(624))>>2)]=((STRING_TABLE.__str64517)|0); +HEAP32[(((_qcc_operators)+(648))>>2)]=((STRING_TABLE.__str65518)|0); +HEAP32[(((_qcc_operators)+(672))>>2)]=((STRING_TABLE.__str66519)|0); +HEAP32[((_opts_flag_list)>>2)]=((STRING_TABLE.__str37490)|0); +HEAP32[(((_opts_flag_list)+(8))>>2)]=((STRING_TABLE.__str38491)|0); +HEAP32[(((_opts_flag_list)+(16))>>2)]=((STRING_TABLE.__str39492)|0); +HEAP32[(((_opts_flag_list)+(24))>>2)]=((STRING_TABLE.__str40493)|0); +HEAP32[((_opts_warn_list)>>2)]=((STRING_TABLE.__str20473)|0); +HEAP32[(((_opts_warn_list)+(8))>>2)]=((STRING_TABLE.__str21474)|0); +HEAP32[(((_opts_warn_list)+(16))>>2)]=((STRING_TABLE.__str22475)|0); +HEAP32[(((_opts_warn_list)+(24))>>2)]=((STRING_TABLE.__str23476)|0); +HEAP32[(((_opts_warn_list)+(32))>>2)]=((STRING_TABLE.__str24477)|0); +HEAP32[(((_opts_warn_list)+(40))>>2)]=((STRING_TABLE.__str25478)|0); +HEAP32[(((_opts_warn_list)+(48))>>2)]=((STRING_TABLE.__str26479)|0); +HEAP32[(((_opts_warn_list)+(56))>>2)]=((STRING_TABLE.__str27480)|0); +HEAP32[(((_opts_warn_list)+(64))>>2)]=((STRING_TABLE.__str28481)|0); +HEAP32[(((_opts_warn_list)+(72))>>2)]=((STRING_TABLE.__str29482)|0); +HEAP32[(((_opts_warn_list)+(80))>>2)]=((STRING_TABLE.__str30483)|0); +HEAP32[(((_opts_warn_list)+(88))>>2)]=((STRING_TABLE.__str31484)|0); +HEAP32[(((_opts_warn_list)+(96))>>2)]=((STRING_TABLE.__str32485)|0); +HEAP32[(((_opts_warn_list)+(104))>>2)]=((STRING_TABLE.__str33486)|0); +HEAP32[(((_opts_warn_list)+(112))>>2)]=((STRING_TABLE.__str34487)|0); +HEAP32[(((_opts_warn_list)+(120))>>2)]=((STRING_TABLE.__str35488)|0); +HEAP32[(((_opts_warn_list)+(128))>>2)]=((STRING_TABLE.__str36489)|0); +FUNCTION_TABLE = [0,0,_ast_return_codegen,0,_ast_ifthen_codegen,0,_ast_value_codegen,0,__ast_node_destroy,0,_ast_return_delete,0,_ast_unary_delete,0,_ast_member_codegen,0,_ast_binstore_codegen,0,_ast_ifthen_delete,0,_ast_entfield_codegen,0,_ast_expression_delete_full,0,_ast_unary_codegen,0,_ast_store_delete,0,_ast_loop_delete,0,_ast_value_delete,0,_ast_function_delete,0,_printf,0,_ast_binary_codegen,0,_ast_member_delete,0,_ast_binstore_delete,0,_ast_call_delete,0,_ast_binary_delete,0,_ast_entfield_delete,0,_ast_store_codegen,0,_ast_loop_codegen,0,_ast_call_codegen,0,_ast_block_delete,0,_ast_block_codegen,0]; Module["FUNCTION_TABLE"] = FUNCTION_TABLE; + + +function run(args) { + args = args || Module['arguments']; + + if (runDependencies > 0) { + Module.printErr('run() called, but dependencies remain, so not running'); + return 0; + } + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + var toRun = Module['preRun']; + Module['preRun'] = []; + for (var i = toRun.length-1; i >= 0; i--) { + toRun[i](); } - - select = document.getElementById("eg"); - change = select.options[select.selectedIndex].value; - if (change != example) { - example = change; + if (runDependencies > 0) { + // a preRun added a dependency, run will be called later + return 0; } + } + + function doRun() { + var ret = 0; + calledRun = true; + if (Module['_main']) { + preMain(); + ret = Module.callMain(args); + if (!Module['noExitRuntime']) { + exitRuntime(); + } + } + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length > 0) { + Module['postRun'].pop()(); + } + } + return ret; + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + return 0; + } else { + return doRun(); + } +} +Module['run'] = run; + +// {{PRE_RUN_ADDITIONS}} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +initRuntime(); + +var shouldRunNow = true; +if (Module['noInitialRun']) { + shouldRunNow = false; +} + +if (shouldRunNow) { + var ret = run(); +} + +// {{POST_RUN_ADDITIONS}} + +var std = "gmqcc"; +function update() { } function compile() { - var string = '"' + document.getElementById("input").value + '"'; - string += " -std="+std+" "; - document.getElementById("output").value = string; + run(["-std=gmqcc", "-debug", "-memchk", document.getElementById("input").value.replace("\\r?\\n", "\\\n")]); } + + + + + + // {{MODULE_ADDITIONS}} + + +// EMSCRIPTEN_GENERATED_FUNCTIONS: ["_parse_if","_parser_t_imm_float_add","_options_set","_parse_expression_leave","_ir_instr_params_remove","_ir_builder_create_global","_ast_expression_init","_paramlist_t_p_add","_parser_global_statement","_ast_node_init","_parser_const_vector","_ir_value_out","_lex_finish_ident","_code_write","_ir_value_life_merge","_ast_return_new","_ir_block_create_binop","_lex_filenames_add","_util_strdup","_ir_value_life_add","_ast_ifthen_delete","_ir_function_collect_value","_ir_function_set_name","_ir_value_delete","_ir_value_var","_ir_block_living_add_instr","_parser_t_locals_add","_code_init","_parser_compile","_options_long_witharg","_ir_function_locals_add","_ir_value_set_vector","_parser_find_param","_ast_block_codegen","_ir_block_living_add","_shunt_out_add","_ir_block_create_store","_code_chars_add","_ast_function_new","_parser_close_paren","_ir_value_life_remove","_ir_value_writes_find","_ir_function_finalize","_parser_close_call","_code_functions_add","_lex_try_digraph","_ir_block_create_if","_ir_instr_dump","_isxdigit_only","_lex_finish_digit","_lex_tokench","_lex_try_trigraph","_ir_value_life_merge_into","_free","_shunt_ops_add","_ir_value_reads_remove","_parse_variable","_lex_token_new","_ir_block_create_return","_lexwarn","_code_genstring","_ast_loop_codegen","_ast_expression_common_params_add","_ir_builder_new","_ast_store_codegen","_code_alloc_field","_ir_builder_set_name","_ir_function_values_add","_options_setflag","_options_parse","_options_setwarn","_util_memory_d","_ir_block_create_general_instr","_ast_member_new","_release_unused_segments","_ast_block_set_type","_irerror","_ast_block_collect_add","_ir_builder_filestring","_ir_instr_new","_main","_parser_find_local","_ast_return_codegen","_ir_naive_phi_emit_store","_parser_const_vector_0","_options_long_witharg_all","_vec3_mulvv","_ast_block_exprs_add","_ast_value_codegen","_segment_holding","_lex_finish_frames","_lex_open_string","_options_long_gcc","_ast_return_delete","_parser_init","_token_value_add","_progdefs_crc_sum","_ast_value_set_name","_ast_unary_delete","_util_strtocmd","_malloc","_ir_function_create_block","_parsewarning","_util_memory_a","_ir_value_set_field","_ir_values_overlap","_ir_function_calculate_liferanges","_gen_global_field","_parse_function_body","_ast_value_new","_ir_value_writes_remove","_ast_type_adopt_impl","_lexerror","_lex_skipwhite","_parser_const_string","_code_fields_add","_ir_instr_delete","_parse_while","_ir_function_delete_quick","_ir_block_naive_phi","_parser_compile_string","_parse_for","_ir_builder_delete","_ast_compare_type","_lex_fgetc","_parser_const_float","_mmap_alloc","_vec3_mulvf","_progdefs_crc_file","_util_getline","_ast_block_collect","_ir_value_set_name","_ir_function_blocks_add","_ast_function_delete","_parser_t_imm_vector_add","_ir_value_code_setaddr","_ast_binstore_delete","_ir_block_set_label","_lex_finish_string","_ir_call_param","_ir_block_life_prop_previous","_ast_call_delete","_function_allocator_sizes_add","_ast_binary_delete","_parser_reclassify_token","_vec3_add","_ast_binstore_new","_code_statements_add","_lex_cleanup","_parser_sy_pop","_parse_block","_ir_block_life_propagate","_ir_builder_fields_add","_vec3_sub","_parser_const_float_0","_parser_find_field","_ast_ifthen_new","_ast_local_codegen","_ast_shallow_type","_ir_value_vector_v_add","_util_crc16","_util_debug","_ir_function_new","_ast_type_to_string","_parser_next","_sys_trim","_ast_function_blocks_add","_ir_block_delete","_ir_value_life_insert","_ir_block_instr_remove","_function_allocator_locals_add","_cvprintmsg","_ast_loop_new","_ir_builder_gen_field","_parser_find_var","_parser_t_imm_string_add","_parseerror","_ir_block_new","_options_setflag_all","_usage","_gen_global_function_code","_gen_global_pointer","_ast_block_locals_add","_ir_block_enumerate","_parse_block_into","_ast_block_new","_ir_value_writes_add","_prepend_alloc","_ir_instr_params_add","_ast_member_codegen","_ir_builder_get_global","_ir_function_blocks_remove","_ir_builder_filenames_add","_ir_function_allocate_locals","_parse_expression","_ir_block_exits_add","_progdefs_crc_both","_parser_cleanup","_genwarning","_ir_builder_create_function","_ir_block_entries_add","_ir_block_delete_quick","_tmalloc_small","_ast_type_copy","_parser_const_vector_f","_syblock","_ast_binary_new","_ast_loop_delete","_ir_block_create_load_from_ent","_ir_block_create_fieldaddress","_ir_instr_op","_parser_strdup","_syexp","_lex_getch","_parse_statement","_ir_value_dump","_ast_function_label","_ast_member_delete","_ir_block_dump","_ir_value_vector_member","_code_defs_add","_parser_t_fields_add","_ir_block_living_remove","_lex_open","_lex_parse_frame","_ir_function_dump","_ir_call_value","_ir_block_create_jump","_dump_phi","_lex_close","_ast_call_check_types","_init_bins","_parse_statement_or_block","_asterror","_irwarning","_ast_call_new","_code_globals_add","_ast_entfield_codegen","_isident","_function_allocator_alloc","_ir_value_set_string","_sys_alloc","_ir_builder_get_function","_ir_builder_gen_global","_ir_function_naive_phi","_generate_checksum","_options_witharg","_ast_ifthen_codegen","_syop","_gen_global_function","_gen_blocks_recursive","_ir_function_params_add","_ir_strdup","__ast_node_destroy","_ir_value_code_addr","_util_fopen","_gen_function_code","_lex_endtoken","_ir_value_set_float","_ast_unary_new","_ir_block_instr_add","_parser_pop_local","_ast_binstore_codegen","_ast_value_copy","_ast_entfield_new","_qc_opname","_progs_nextline","_init_top","_lex_do","_ast_expression_delete","_ir_builder_dump","_parser_finish","_ir_block_create_call","_function_allocator_positions_add","_ir_builder_create_field","_parse_dowhile","_ir_op_read_write","_vprintmsg","_init_mparams","_ast_expression_delete_full","_ast_unary_codegen","_ast_store_delete","_ir_block_living_find","_ir_block_create_store_op","_ir_function_create_local","_ast_store_new","_ast_value_delete","_ast_call_codegen","_create_vector_members","_ir_block_create_unary","_ast_entfield_delete","_ast_binary_codegen","_ir_builder_globals_add","_ir_builder_functions_add","_ir_function_enumerate","_ir_value_reads_add","_ir_function_delete","_ir_instr_delete_quick","_util_meminfo","_add_segment","_util_strtononcmd","_parser_find_global","_ir_builder_filestrings_add","_util_endianswap","_ir_builder_get_field","_lex_file_frames_add","_ast_type_to_string_impl","_parser_compile_file","_parse_type","_isident_start","_lex_ungetch","_ast_global_codegen","_parser_t_globals_add","_tmalloc_large","_items_add","_parser_t_functions_add","_ir_builder_generate","_ast_block_delete","_ast_function_codegen","_ir_value_reads_find","_ast_call_params_add","_syparen"] + diff --git a/javascripts/vm.js b/javascripts/vm.js new file mode 100644 index 0000000..ef6617c --- /dev/null +++ b/javascripts/vm.js @@ -0,0 +1,22093 @@ +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. +// TODO: " u s e s t r i c t "; + +try { + this['Module'] = Module; +} catch(e) { + this['Module'] = Module = {}; +} + +// The environment setup code below is customized to use Module. +// *** Environment setup code *** +var ENVIRONMENT_IS_NODE = typeof process === 'object'; +var ENVIRONMENT_IS_WEB = typeof window === 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (ENVIRONMENT_IS_NODE) { + // Expose functionality in the same simple way that the shells work + // Note that we pollute the global namespace here, otherwise we break in node + Module['print'] = function(x) { + process['stdout'].write(x + '\n'); + }; + Module['printErr'] = function(x) { + process['stderr'].write(x + '\n'); + }; + + var nodeFS = require('fs'); + var nodePath = require('path'); + + Module['read'] = function(filename) { + filename = nodePath['normalize'](filename); + var ret = nodeFS['readFileSync'](filename).toString(); + // The path is absolute if the normalized version is the same as the resolved. + if (!ret && filename != nodePath['resolve'](filename)) { + filename = path.join(__dirname, '..', 'src', filename); + ret = nodeFS['readFileSync'](filename).toString(); + } + return ret; + }; + + Module['load'] = function(f) { + globalEval(read(f)); + }; + + if (!Module['arguments']) { + Module['arguments'] = process['argv'].slice(2); + } +} + +if (ENVIRONMENT_IS_SHELL) { + Module['print'] = print; + if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm + + // Polyfill over SpiderMonkey/V8 differences + if (typeof read != 'undefined') { + Module['read'] = read; + } else { + Module['read'] = function(f) { snarf(f) }; + } + + if (!Module['arguments']) { + if (typeof scriptArgs != 'undefined') { + Module['arguments'] = scriptArgs; + } else if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + } +} + +if (ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER) { + if (!Module['print']) { + Module['print'] = function(x) { + console.log(x); + }; + } + + if (!Module['printErr']) { + Module['printErr'] = function(x) { + console.log(x); + }; + } +} + +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + Module['read'] = function(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (!Module['arguments']) { + if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + } +} + +if (ENVIRONMENT_IS_WORKER) { + // We can do very little here... + var TRY_USE_DUMP = false; + if (!Module['print']) { + Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) { + dump(x); + }) : (function(x) { + // self.postMessage(x); // enable this if you want stdout to be sent as messages + })); + } + + Module['load'] = importScripts; +} + +if (!ENVIRONMENT_IS_WORKER && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL) { + // Unreachable because SHELL is dependant on the others + throw 'Unknown runtime environment. Where are we?'; +} + +function globalEval(x) { + eval.call(null, x); +} +if (!Module['load'] == 'undefined' && Module['read']) { + Module['load'] = function(f) { + globalEval(Module['read'](f)); + }; +} +if (!Module['print']) { + Module['print'] = function(){}; +} +if (!Module['printErr']) { + Module['printErr'] = Module['print']; +} +if (!Module['arguments']) { + Module['arguments'] = []; +} +// *** Environment setup code *** + +// Closure helpers +Module.print = Module['print']; +Module.printErr = Module['printErr']; + +// Callbacks +if (!Module['preRun']) Module['preRun'] = []; +if (!Module['postRun']) Module['postRun'] = []; + + +// === Auto-generated preamble library stuff === + +//======================================== +// Runtime code shared with compiler +//======================================== + +var Runtime = { + stackSave: function () { + return STACKTOP; + }, + stackRestore: function (stackTop) { + STACKTOP = stackTop; + }, + forceAlign: function (target, quantum) { + quantum = quantum || 4; + if (quantum == 1) return target; + if (isNumber(target) && isNumber(quantum)) { + return Math.ceil(target/quantum)*quantum; + } else if (isNumber(quantum) && isPowerOfTwo(quantum)) { + var logg = log2(quantum); + return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')'; + } + return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum; + }, + isNumberType: function (type) { + return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES; + }, + isPointerType: function isPointerType(type) { + return type[type.length-1] == '*'; +}, + isStructType: function isStructType(type) { + if (isPointerType(type)) return false; + if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs + if (/?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types + // See comment in isStructPointerType() + return type[0] == '%'; +}, + INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0}, + FLOAT_TYPES: {"float":0,"double":0}, + bitshift64: function (low, high, op, bits) { + var ander = Math.pow(2, bits)-1; + if (bits < 32) { + switch (op) { + case 'shl': + return [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))]; + case 'ashr': + return [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0]; + case 'lshr': + return [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits]; + } + } else if (bits == 32) { + switch (op) { + case 'shl': + return [0, low]; + case 'ashr': + return [high, (high|0) < 0 ? ander : 0]; + case 'lshr': + return [high, 0]; + } + } else { // bits > 32 + switch (op) { + case 'shl': + return [0, low << (bits - 32)]; + case 'ashr': + return [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0]; + case 'lshr': + return [high >>> (bits - 32) , 0]; + } + } + abort('unknown bitshift64 op: ' + [value, op, bits]); + }, + or64: function (x, y) { + var l = (x | 0) | (y | 0); + var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + and64: function (x, y) { + var l = (x | 0) & (y | 0); + var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + xor64: function (x, y) { + var l = (x | 0) ^ (y | 0); + var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296; + return l + h; + }, + getNativeTypeSize: function (type, quantumSize) { + if (Runtime.QUANTUM_SIZE == 1) return 1; + var size = { + '%i1': 1, + '%i8': 1, + '%i16': 2, + '%i32': 4, + '%i64': 8, + "%float": 4, + "%double": 8 + }['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc + if (!size) { + if (type.charAt(type.length-1) == '*') { + size = Runtime.QUANTUM_SIZE; // A pointer + } else if (type[0] == 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 == 0); + size = bits/8; + } + } + return size; + }, + getNativeFieldSize: function (type) { + return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE); + }, + dedup: function dedup(items, ident) { + var seen = {}; + if (ident) { + return items.filter(function(item) { + if (seen[item[ident]]) return false; + seen[item[ident]] = true; + return true; + }); + } else { + return items.filter(function(item) { + if (seen[item]) return false; + seen[item] = true; + return true; + }); + } +}, + set: function set() { + var args = typeof arguments[0] === 'object' ? arguments[0] : arguments; + var ret = {}; + for (var i = 0; i < args.length; i++) { + ret[args[i]] = 0; + } + return ret; +}, + calculateStructAlignment: function calculateStructAlignment(type) { + type.flatSize = 0; + type.alignSize = 0; + var diffs = []; + var prev = -1; + type.flatIndexes = type.fields.map(function(field) { + var size, alignSize; + if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) { + size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s. + alignSize = size; + } else if (Runtime.isStructType(field)) { + size = Types.types[field].flatSize; + alignSize = Types.types[field].alignSize; + } else { + throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]); + } + alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE); + type.alignSize = Math.max(type.alignSize, alignSize); + var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory + type.flatSize = curr + size; + if (prev >= 0) { + diffs.push(curr-prev); + } + prev = curr; + return curr; + }); + type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize); + if (diffs.length == 0) { + type.flatFactor = type.flatSize; + } else if (Runtime.dedup(diffs).length == 1) { + type.flatFactor = diffs[0]; + } + type.needsFlattening = (type.flatFactor != 1); + return type.flatIndexes; + }, + generateStructInfo: function (struct, typeName, offset) { + var type, alignment; + if (typeName) { + offset = offset || 0; + type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName]; + if (!type) return null; + if (type.fields.length != struct.length) { + printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo'); + return null; + } + alignment = type.flatIndexes; + } else { + var type = { fields: struct.map(function(item) { return item[0] }) }; + alignment = Runtime.calculateStructAlignment(type); + } + var ret = { + __size__: type.flatSize + }; + if (typeName) { + struct.forEach(function(item, i) { + if (typeof item === 'string') { + ret[item] = alignment[i] + offset; + } else { + // embedded struct + var key; + for (var k in item) key = k; + ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]); + } + }); + } else { + struct.forEach(function(item, i) { + ret[item[1]] = alignment[i]; + }); + } + return ret; + }, + addFunction: function (func) { + var ret = FUNCTION_TABLE.length; + FUNCTION_TABLE.push(func); + FUNCTION_TABLE.push(0); + return ret; + }, + warnOnce: function (text) { + if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {}; + if (!Runtime.warnOnce.shown[text]) { + Runtime.warnOnce.shown[text] = 1; + Module.printErr(text); + } + }, + funcWrappers: {}, + getFuncWrapper: function (func) { + if (!Runtime.funcWrappers[func]) { + Runtime.funcWrappers[func] = function() { + FUNCTION_TABLE[func].apply(null, arguments); + }; + } + return Runtime.funcWrappers[func]; + }, + UTF8Processor: function () { + var buffer = []; + var needed = 0; + this.processCChar = function (code) { + code = code & 0xff; + if (needed) { + buffer.push(code); + needed--; + } + if (buffer.length == 0) { + if (code < 128) return String.fromCharCode(code); + buffer.push(code); + if (code > 191 && code < 224) { + needed = 1; + } else { + needed = 2; + } + return ''; + } + if (needed > 0) return ''; + var c1 = buffer[0]; + var c2 = buffer[1]; + var c3 = buffer[2]; + var ret; + if (c1 > 191 && c1 < 224) { + ret = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63)); + } else { + ret = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); + } + buffer.length = 0; + return ret; + } + this.processJSString = function(string) { + string = unescape(encodeURIComponent(string)); + var ret = []; + for (var i = 0; i < string.length; i++) { + ret.push(string.charCodeAt(i)); + } + return ret; + } + }, + 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; }, + staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP += size;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; }, + alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; }, + makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; }, + QUANTUM_SIZE: 4, + __dummy__: 0 +} + + + +var CorrectionsMonitor = { + MAX_ALLOWED: 0, // XXX + corrections: 0, + sigs: {}, + + note: function(type, succeed, sig) { + if (!succeed) { + this.corrections++; + if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!'); + } + }, + + print: function() { + } +}; + + + + + +//======================================== +// Runtime essentials +//======================================== + +var __THREW__ = false; // Used in checking for thrown exceptions. + +var ABORT = false; + +var undef = 0; +// tempInt is used for 32-bit signed values or smaller. tempBigInt is used +// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt +var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD; +var tempI64, tempI64b; + +function abort(text) { + Module.print(text + ':\n' + (new Error).stack); + ABORT = true; + throw "Assertion: " + text; +} + +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +var globalScope = this; + +// C calling interface. A convenient way to call C functions (in C files, or +// defined with extern "C"). +// +// Note: LLVM optimizations can inline and remove functions, after which you will not be +// able to call them. Adding +// +// __attribute__((used)) +// +// to the function definition will prevent that. +// +// Note: Closure optimizations will minify function names, making +// functions no longer callable. If you run closure (on by default +// in -O2 and above), you should export the functions you will call +// by calling emcc with something like +// +// -s EXPORTED_FUNCTIONS='["_func1","_func2"]' +// +// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C") +// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and +// 'array' for JavaScript arrays and typed arrays). +// @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, +// except that 'array' is not possible (there is no way for us to know the length of the array) +// @param args An array of the arguments to the function, as native JS values (as in returnType) +// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack). +// @return The return value, as a native JS value (as in returnType) +function ccall(ident, returnType, argTypes, args) { + var stack = 0; + function toC(value, type) { + if (type == 'string') { + if (value === null || value === undefined || value === 0) return 0; // null string + if (!stack) stack = Runtime.stackSave(); + var ret = Runtime.stackAlloc(value.length+1); + writeStringToMemory(value, ret); + return ret; + } else if (type == 'array') { + if (!stack) stack = Runtime.stackSave(); + var ret = Runtime.stackAlloc(value.length); + writeArrayToMemory(value, ret); + return ret; + } + return value; + } + function fromC(value, type) { + if (type == 'string') { + return Pointer_stringify(value); + } + assert(type != 'array'); + return value; + } + try { + var func = eval('_' + ident); + } catch(e) { + try { + func = globalScope['Module']['_' + ident]; // closure exported function + } catch(e) {} + } + assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)'); + var i = 0; + var cArgs = args ? args.map(function(arg) { + return toC(arg, argTypes[i++]); + }) : []; + var ret = fromC(func.apply(null, cArgs), returnType); + if (stack) Runtime.stackRestore(stack); + return ret; +} +Module["ccall"] = ccall; + +// Returns a native JS wrapper for a C function. This is similar to ccall, but +// returns a function you can call repeatedly in a normal way. For example: +// +// var my_function = cwrap('my_c_function', 'number', ['number', 'number']); +// alert(my_function(5, 22)); +// alert(my_function(99, 12)); +// +function cwrap(ident, returnType, argTypes) { + // TODO: optimize this, eval the whole function once instead of going through ccall each time + return function() { + return ccall(ident, returnType, argTypes, Array.prototype.slice.call(arguments)); + } +} +Module["cwrap"] = cwrap; + +// Sets a value in memory in a dynamic way at run-time. Uses the +// type data. This is the same as makeSetValue, except that +// makeSetValue is done at compile-time and generates the needed +// code then, whereas this function picks the right code at +// run-time. +// Note that setValue and getValue only do *aligned* writes and reads! +// Note that ccall uses JS types as for defining types, while setValue and +// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[(ptr)]=value; break; + case 'i8': HEAP8[(ptr)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,Math.min(Math.floor((value)/4294967296), 4294967295)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': (tempDoubleF64[0]=value,HEAP32[((ptr)>>2)]=tempDoubleI32[0],HEAP32[(((ptr)+(4))>>2)]=tempDoubleI32[1]); break; + default: abort('invalid type for setValue: ' + type); + } +} +Module['setValue'] = setValue; + +// Parallel to setValue. +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[(ptr)]; + case 'i8': return HEAP8[(ptr)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return (tempDoubleI32[0]=HEAP32[((ptr)>>2)],tempDoubleI32[1]=HEAP32[(((ptr)+(4))>>2)],tempDoubleF64[0]); + default: abort('invalid type for setValue: ' + type); + } + return null; +} +Module['getValue'] = getValue; + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_STATIC = 2; // Cannot be freed +Module['ALLOC_NORMAL'] = ALLOC_NORMAL; +Module['ALLOC_STACK'] = ALLOC_STACK; +Module['ALLOC_STATIC'] = ALLOC_STATIC; + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +function allocate(slab, types, allocator) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length)); + + if (zeroinit) { + _memset(ret, 0, size); + return ret; + } + + var i = 0, type; + while (i < size) { + var curr = slab[i]; + + if (typeof curr === 'function') { + curr = Runtime.getFunctionIndex(curr); + } + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + assert(type, 'Must know what type to store in allocate!'); + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + i += Runtime.getNativeTypeSize(type); + } + + return ret; +} +Module['allocate'] = allocate; + +function Pointer_stringify(ptr, /* optional */ length) { + var utf8 = new Runtime.UTF8Processor(); + var nullTerminated = typeof(length) == "undefined"; + var ret = ""; + var i = 0; + var t; + while (1) { + t = HEAPU8[((ptr)+(i))]; + if (nullTerminated && t == 0) break; + ret += utf8.processCChar(t); + i += 1; + if (!nullTerminated && i == length) break; + } + return ret; +} +Module['Pointer_stringify'] = Pointer_stringify; + +function Array_stringify(array) { + var ret = ""; + for (var i = 0; i < array.length; i++) { + ret += String.fromCharCode(array[i]); + } + return ret; +} +Module['Array_stringify'] = Array_stringify; + +// Memory management + +var FUNCTION_TABLE; // XXX: In theory the indexes here can be equal to pointers to stacked or malloced memory. Such comparisons should + // be false, but can turn out true. We should probably set the top bit to prevent such issues. + +var PAGE_SIZE = 4096; +function alignMemoryPage(x) { + return ((x+4095)>>12)<<12; +} + +var HEAP; +var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + +var STACK_ROOT, STACKTOP, STACK_MAX; +var STATICTOP; +function enlargeMemory() { + abort('Cannot enlarge memory arrays. Adjust TOTAL_MEMORY (currently ' + TOTAL_MEMORY + ') or compile with ALLOW_MEMORY_GROWTH'); +} + +var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; +var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 10485760; +var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152; + +// Initialize the runtime's memory +// check for full engine support (use string 'subarray' to avoid closure compiler confusion) + assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']), + 'Cannot fallback to non-typed array case: Code is too specialized'); + + var buffer = new ArrayBuffer(TOTAL_MEMORY); + HEAP8 = new Int8Array(buffer); + HEAP16 = new Int16Array(buffer); + HEAP32 = new Int32Array(buffer); + HEAPU8 = new Uint8Array(buffer); + HEAPU16 = new Uint16Array(buffer); + HEAPU32 = new Uint32Array(buffer); + HEAPF32 = new Float32Array(buffer); + HEAPF64 = new Float64Array(buffer); + + // Endianness check (note: assumes compiler arch was little-endian) + HEAP32[0] = 255; + assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system'); + +Module['HEAP'] = HEAP; +Module['HEAP8'] = HEAP8; +Module['HEAP16'] = HEAP16; +Module['HEAP32'] = HEAP32; +Module['HEAPU8'] = HEAPU8; +Module['HEAPU16'] = HEAPU16; +Module['HEAPU32'] = HEAPU32; +Module['HEAPF32'] = HEAPF32; +Module['HEAPF64'] = HEAPF64; + +STACK_ROOT = STACKTOP = Runtime.alignMemory(1); +STACK_MAX = STACK_ROOT + TOTAL_STACK; + +var tempDoublePtr = Runtime.alignMemory(STACK_MAX, 8); +var tempDoubleI8 = HEAP8.subarray(tempDoublePtr); +var tempDoubleI32 = HEAP32.subarray(tempDoublePtr >> 2); +var tempDoubleF32 = HEAPF32.subarray(tempDoublePtr >> 2); +var tempDoubleF64 = HEAPF64.subarray(tempDoublePtr >> 3); +function copyTempFloat(ptr) { // functions, because inlining this code is increases code size too much + tempDoubleI8[0] = HEAP8[ptr]; + tempDoubleI8[1] = HEAP8[ptr+1]; + tempDoubleI8[2] = HEAP8[ptr+2]; + tempDoubleI8[3] = HEAP8[ptr+3]; +} +function copyTempDouble(ptr) { + tempDoubleI8[0] = HEAP8[ptr]; + tempDoubleI8[1] = HEAP8[ptr+1]; + tempDoubleI8[2] = HEAP8[ptr+2]; + tempDoubleI8[3] = HEAP8[ptr+3]; + tempDoubleI8[4] = HEAP8[ptr+4]; + tempDoubleI8[5] = HEAP8[ptr+5]; + tempDoubleI8[6] = HEAP8[ptr+6]; + tempDoubleI8[7] = HEAP8[ptr+7]; +} +STACK_MAX = tempDoublePtr + 8; + +STATICTOP = alignMemoryPage(STACK_MAX); + +assert(STATICTOP < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY + +var nullString = allocate(intArrayFromString('(null)'), 'i8', ALLOC_STATIC); + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + var func = callback.func; + if (typeof func === 'number') { + func = FUNCTION_TABLE[func]; + } + func(callback.arg === undefined ? null : callback.arg); + } +} + +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown + +function initRuntime() { + callRuntimeCallbacks(__ATINIT__); +} +function preMain() { + callRuntimeCallbacks(__ATMAIN__); +} +function exitRuntime() { + callRuntimeCallbacks(__ATEXIT__); + + // Print summary of correction activity + CorrectionsMonitor.print(); +} + +function String_len(ptr) { + var i = ptr; + while (HEAP8[(i++)]) {}; // Note: should be |!= 0|, technically. But this helps catch bugs with undefineds + return i - ptr - 1; +} +Module['String_len'] = String_len; + +// Tools + +// This processes a JS string into a C-line array of numbers, 0-terminated. +// For LLVM-originating strings, see parser.js:parseLLVMString function +function intArrayFromString(stringy, dontAddNull, length /* optional */) { + var ret = (new Runtime.UTF8Processor()).processJSString(stringy); + if (length) { + ret.length = length; + } + if (!dontAddNull) { + ret.push(0); + } + return ret; +} +Module['intArrayFromString'] = intArrayFromString; + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} +Module['intArrayToString'] = intArrayToString; + +// Write a Javascript array to somewhere in the heap +function writeStringToMemory(string, buffer, dontAddNull) { + var array = intArrayFromString(string, dontAddNull); + var i = 0; + while (i < array.length) { + var chr = array[i]; + HEAP8[((buffer)+(i))]=chr + i = i + 1; + } +} +Module['writeStringToMemory'] = writeStringToMemory; + +function writeArrayToMemory(array, buffer) { + for (var i = 0; i < array.length; i++) { + HEAP8[((buffer)+(i))]=array[i]; + } +} +Module['writeArrayToMemory'] = writeArrayToMemory; + +var STRING_TABLE = []; + +function unSign(value, bits, ignore, sig) { + if (value >= 0) { + return value; + } + 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 + : Math.pow(2, bits) + value; + // TODO: clean up previous line +} +function reSign(value, bits, ignore, sig) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + 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 + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// PRE_RUN_ADDITIONS (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyTracking = {}; +var calledRun = false; +var runDependencyWatcher = null; +function addRunDependency(id) { + runDependencies++; + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval !== 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(function() { + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + Module.printErr('still waiting on run dependencies:'); + } + Module.printErr('dependency: ' + dep); + } + if (shown) { + Module.printErr('(end of list)'); + } + }, 6000); + } + } else { + Module.printErr('warning: run dependency added without ID'); + } +} +Module['addRunDependency'] = addRunDependency; +function removeRunDependency(id) { + runDependencies--; + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + Module.printErr('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (!calledRun) run(); + } +} +Module['removeRunDependency'] = removeRunDependency; + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + +// === Body === + + + + +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. + +function _qc_program_code_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+8)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+8)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+4)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<3))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+4)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<3))|0); + var $31=$24; + var $32=$30; + 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)]; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+8)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+8)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+8)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+12)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+8)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56<<3))|0); + var $58=_util_memory_a($57, 32, ((STRING_TABLE.__str)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+4)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+8)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72<<3))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 2); + var $74=$2; + var $75=(($74+4)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 32, ((STRING_TABLE.__str)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+4)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_code_remove["X"]=1; + +function _qc_program_code_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + 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)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+8)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+12)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+12)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+12)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+12)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+12)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26<<3))|0); + var $28=_util_memory_a($27, 32, ((STRING_TABLE.__str)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36+4)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+8)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42<<3))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 2); + var $44=$2; + var $45=(($44+4)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 32, ((STRING_TABLE.__str)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49+4)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+8)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+4)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54<<3))|0); + var $60=$59; + var $61=$f; + 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)]; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_code_add["X"]=1; + +function _qc_program_defs_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+20)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+20)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+16)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<3))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+16)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<3))|0); + var $31=$24; + var $32=$30; + 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)]; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+20)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+20)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+20)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+24)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+20)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56<<3))|0); + var $58=_util_memory_a($57, 33, ((STRING_TABLE.__str)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+16)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+20)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72<<3))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4); + var $74=$2; + var $75=(($74+16)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 33, ((STRING_TABLE.__str)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+16)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_defs_remove["X"]=1; + +function _qc_program_defs_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + 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)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+20)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+24)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+24)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+24)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+24)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+24)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26<<3))|0); + var $28=_util_memory_a($27, 33, ((STRING_TABLE.__str)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36+16)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+20)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42<<3))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4); + var $44=$2; + var $45=(($44+16)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 33, ((STRING_TABLE.__str)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49+16)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+20)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+16)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54<<3))|0); + var $60=$59; + var $61=$f; + 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)]; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_defs_add["X"]=1; + +function _qc_program_fields_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+32)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+32)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+28)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20<<3))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+28)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26<<3))|0); + var $31=$24; + var $32=$30; + 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)]; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+32)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+32)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+32)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+36)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+32)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56<<3))|0); + var $58=_util_memory_a($57, 34, ((STRING_TABLE.__str)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+28)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+32)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72<<3))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4); + var $74=$2; + var $75=(($74+28)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 34, ((STRING_TABLE.__str)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+28)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_fields_remove["X"]=1; + +function _qc_program_fields_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + 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)]; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+32)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+36)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+36)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+36)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+36)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+36)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26<<3))|0); + var $28=_util_memory_a($27, 34, ((STRING_TABLE.__str)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36+28)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+32)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42<<3))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4); + var $44=$2; + var $45=(($44+28)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 34, ((STRING_TABLE.__str)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49+28)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+32)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+28)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54<<3))|0); + var $60=$59; + var $61=$f; + 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)]; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_fields_add["X"]=1; + +function _qc_program_functions_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+44)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+44)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+40)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20)*(36))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+40)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26)*(36))|0); + var $31=$24; + var $32=$30; + 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++) { + HEAP32[$$dest] = HEAP32[$$src] + }; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+44)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+44)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+44)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+48)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+44)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)*(36))|0); + var $58=_util_memory_a($57, 35, ((STRING_TABLE.__str)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+40)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+44)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72)*(36))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4); + var $74=$2; + var $75=(($74+40)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 35, ((STRING_TABLE.__str)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+40)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_functions_remove["X"]=1; + +function _qc_program_functions_add($self, $f) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + 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++) { + HEAP32[$$dest] = HEAP32[$$src] +}; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $reall; + $2=$self; + var $3=$2; + var $4=(($3+44)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=$2; + var $7=(($6+48)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)|0)==(($8)|0); + if ($9) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $11=$2; + var $12=(($11+48)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $16=$2; + var $17=(($16+48)|0); + HEAP32[(($17)>>2)]=16; + __label__ = 6; break; + case 5: + var $19=$2; + var $20=(($19+48)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=((($21<<1))|0); + HEAP32[(($20)>>2)]=$22; + __label__ = 6; break; + case 6: + var $24=$2; + var $25=(($24+48)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26)*(36))|0); + var $28=_util_memory_a($27, 35, ((STRING_TABLE.__str)|0)); + var $29=$28; + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$34; + var $36=$2; + var $37=(($36+40)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$38; + var $40=$2; + var $41=(($40+44)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42)*(36))|0); + assert($43 % 1 === 0, 'memcpy given ' + $43 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $39, $43, 4); + var $44=$2; + var $45=(($44+40)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$46; + _util_memory_d($47, 35, ((STRING_TABLE.__str)|0)); + var $48=$reall; + var $49=$2; + var $50=(($49+40)|0); + HEAP32[(($50)>>2)]=$48; + __label__ = 9; break; + case 9: + var $52=$2; + var $53=(($52+44)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+40)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+($54)*(36))|0); + var $60=$59; + var $61=$f; + 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++) { + HEAP32[$$dest] = HEAP32[$$src] + }; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + STACKTOP = __stackBase__; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_functions_add["X"]=1; + +function _qc_program_strings_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+56)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+56)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+52)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+$21)|0); + var $26=HEAP8[($25)]; + var $27=$i; + var $28=$2; + var $29=(($28+52)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+$27)|0); + HEAP8[($31)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+56)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+56)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+56)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+60)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+56)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=(($55)|0); + var $57=_util_memory_a($56, 36, ((STRING_TABLE.__str)|0)); + $reall=$57; + var $58=$reall; + var $59=(($58)|0)!=0; + if ($59) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $62=$reall; + var $63=$2; + var $64=(($63+52)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=$2; + var $67=(($66+56)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=(($68)|0); + assert($69 % 1 === 0, 'memcpy given ' + $69 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($62, $65, $69, 1); + var $70=$2; + var $71=(($70+52)|0); + var $72=HEAP32[(($71)>>2)]; + _util_memory_d($72, 36, ((STRING_TABLE.__str)|0)); + var $73=$reall; + var $74=$2; + var $75=(($74+52)|0); + HEAP32[(($75)>>2)]=$73; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $78=$1; + ; + return $78; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_strings_remove["X"]=1; + +function _qc_program_strings_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+56)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+60)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+60)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+60)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+60)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+60)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27)|0); + var $29=_util_memory_a($28, 36, ((STRING_TABLE.__str)|0)); + $reall=$29; + var $30=$reall; + var $31=(($30)|0)!=0; + if ($31) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $34=$reall; + var $35=$2; + var $36=(($35+52)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$2; + var $39=(($38+56)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($40)|0); + assert($41 % 1 === 0, 'memcpy given ' + $41 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($34, $37, $41, 1); + var $42=$2; + var $43=(($42+52)|0); + var $44=HEAP32[(($43)>>2)]; + _util_memory_d($44, 36, ((STRING_TABLE.__str)|0)); + var $45=$reall; + var $46=$2; + var $47=(($46+52)|0); + HEAP32[(($47)>>2)]=$45; + __label__ = 9; break; + case 9: + var $49=$3; + var $50=$2; + var $51=(($50+56)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=((($52)+(1))|0); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+52)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+$52)|0); + HEAP8[($57)]=$49; + $1=1; + __label__ = 10; break; + case 10: + var $59=$1; + ; + return $59; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_strings_add["X"]=1; + +function _qc_program_strings_append($s, $p, $c) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $reall; + var $oldalloc; + $2=$s; + $3=$p; + $4=$c; + var $5=$2; + var $6=(($5+56)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$4; + var $9=((($7)+($8))|0); + var $10=$2; + var $11=(($10+60)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($9)>>>0) > (($12)>>>0); + if ($13) { __label__ = 3; break; } else { __label__ = 14; break; } + case 3: + var $15=$2; + var $16=(($15+60)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0)!=0; + if ($18) { __label__ = 8; break; } else { __label__ = 4; break; } + case 4: + var $20=$4; + var $21=(($20)>>>0) < 16; + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $26 = 16;__label__ = 7; break; + case 6: + var $24=$4; + var $26 = $24;__label__ = 7; break; + case 7: + var $26; + var $27=$2; + var $28=(($27+60)|0); + HEAP32[(($28)>>2)]=$26; + var $29=$2; + var $30=(($29+60)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31)|0); + var $33=_util_memory_a($32, 37, ((STRING_TABLE.__str)|0)); + var $34=$2; + var $35=(($34+52)|0); + HEAP32[(($35)>>2)]=$33; + __label__ = 13; break; + case 8: + var $37=$2; + var $38=(($37+60)|0); + var $39=HEAP32[(($38)>>2)]; + $oldalloc=$39; + var $40=$2; + var $41=(($40+60)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=((($42<<1))|0); + HEAP32[(($41)>>2)]=$43; + var $44=$2; + var $45=(($44+56)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$4; + var $48=((($46)+($47))|0); + var $49=$2; + var $50=(($49+60)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=(($48)>>>0) >= (($51)>>>0); + if ($52) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $54=$2; + var $55=(($54+56)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=$4; + var $58=((($56)+($57))|0); + var $59=$2; + var $60=(($59+60)|0); + HEAP32[(($60)>>2)]=$58; + __label__ = 10; break; + case 10: + var $62=$2; + var $63=(($62+60)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=(($64)|0); + var $66=_util_memory_a($65, 37, ((STRING_TABLE.__str)|0)); + $reall=$66; + var $67=$reall; + var $68=(($67)|0)!=0; + if ($68) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $70=$oldalloc; + var $71=$2; + var $72=(($71+60)|0); + HEAP32[(($72)>>2)]=$70; + $1=0; + __label__ = 15; break; + case 12: + var $74=$reall; + var $75=$2; + var $76=(($75+52)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=$2; + var $79=(($78+56)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=(($80)|0); + assert($81 % 1 === 0, 'memcpy given ' + $81 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($74, $77, $81, 1); + var $82=$2; + var $83=(($82+52)|0); + var $84=HEAP32[(($83)>>2)]; + _util_memory_d($84, 37, ((STRING_TABLE.__str)|0)); + var $85=$reall; + var $86=$2; + var $87=(($86+52)|0); + HEAP32[(($87)>>2)]=$85; + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $90=$2; + var $91=(($90+56)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=$2; + var $94=(($93+52)|0); + var $95=HEAP32[(($94)>>2)]; + var $96=(($95+$92)|0); + var $97=$3; + var $98=$4; + var $99=(($98)|0); + assert($99 % 1 === 0, 'memcpy given ' + $99 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($96, $97, $99, 1); + var $100=$4; + var $101=$2; + var $102=(($101+56)|0); + var $103=HEAP32[(($102)>>2)]; + var $104=((($103)+($100))|0); + HEAP32[(($102)>>2)]=$104; + $1=1; + __label__ = 15; break; + case 15: + var $106=$1; + ; + return $106; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_strings_append["X"]=1; + +function _qc_program_strings_resize($s, $c) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$s; + $3=$c; + var $4=$3; + var $5=$2; + var $6=(($5+60)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) > (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $10=$3; + var $11=(($10)|0); + var $12=_util_memory_a($11, 38, ((STRING_TABLE.__str)|0)); + $reall=$12; + var $13=$reall; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 11; break; + case 5: + var $17=$reall; + var $18=$2; + var $19=(($18+52)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=$2; + var $22=(($21+56)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23)|0); + assert($24 % 1 === 0, 'memcpy given ' + $24 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($17, $20, $24, 1); + var $25=$3; + var $26=$2; + var $27=(($26+60)|0); + HEAP32[(($27)>>2)]=$25; + var $28=$3; + var $29=$2; + var $30=(($29+56)|0); + HEAP32[(($30)>>2)]=$28; + var $31=$2; + var $32=(($31+52)|0); + var $33=HEAP32[(($32)>>2)]; + _util_memory_d($33, 38, ((STRING_TABLE.__str)|0)); + var $34=$reall; + var $35=$2; + var $36=(($35+52)|0); + HEAP32[(($36)>>2)]=$34; + $1=1; + __label__ = 11; break; + case 6: + var $38=$3; + var $39=$2; + var $40=(($39+56)|0); + HEAP32[(($40)>>2)]=$38; + var $41=$3; + var $42=$2; + var $43=(($42+60)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=Math.floor(((($44)>>>0))/(2)); + var $46=(($41)>>>0) < (($45)>>>0); + if ($46) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $48=$3; + var $49=(($48)|0); + var $50=_util_memory_a($49, 38, ((STRING_TABLE.__str)|0)); + $reall=$50; + var $51=$reall; + var $52=(($51)|0)!=0; + if ($52) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 11; break; + case 9: + var $55=$reall; + var $56=$2; + var $57=(($56+52)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=$3; + var $60=(($59)|0); + assert($60 % 1 === 0, 'memcpy given ' + $60 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($55, $58, $60, 1); + var $61=$2; + var $62=(($61+52)|0); + var $63=HEAP32[(($62)>>2)]; + _util_memory_d($63, 38, ((STRING_TABLE.__str)|0)); + var $64=$reall; + var $65=$2; + var $66=(($65+52)|0); + HEAP32[(($66)>>2)]=$64; + var $67=$3; + var $68=$2; + var $69=(($68+60)|0); + HEAP32[(($69)>>2)]=$67; + __label__ = 10; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $72=$1; + ; + return $72; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_strings_resize["X"]=1; + +function _qc_program_globals_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+68)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+68)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+64)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+64)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+68)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+68)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+68)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+72)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+68)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 39, ((STRING_TABLE.__str)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+64)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+68)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+64)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 39, ((STRING_TABLE.__str)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+64)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_globals_remove["X"]=1; + +function _qc_program_globals_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+68)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+72)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+72)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+72)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+72)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+72)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 39, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+64)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+68)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+64)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 39, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+64)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+68)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+64)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_globals_add["X"]=1; + +function _qc_program_entitydata_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+80)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+80)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+76)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+76)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+80)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+80)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+80)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+84)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+80)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 40, ((STRING_TABLE.__str)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+76)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+80)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+76)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 40, ((STRING_TABLE.__str)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+76)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_entitydata_remove["X"]=1; + +function _qc_program_entitydata_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+80)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+84)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+84)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+84)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+84)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+84)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 40, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+76)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+80)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+76)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 40, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+76)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+80)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+76)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_entitydata_add["X"]=1; + +function _qc_program_entitypool_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+92)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+92)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+88)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+$21)|0); + var $26=HEAP8[($25)]; + var $27=(($26) & 1); + var $28=$i; + var $29=$2; + var $30=(($29+88)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=(($31+$28)|0); + var $33=(($27)&1); + HEAP8[($32)]=$33; + __label__ = 7; break; + case 7: + var $35=$i; + var $36=((($35)+(1))|0); + $i=$36; + __label__ = 5; break; + case 8: + var $38=$2; + var $39=(($38+92)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=((($40)-(1))|0); + HEAP32[(($39)>>2)]=$41; + var $42=$2; + var $43=(($42+92)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=$2; + var $46=(($45+92)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=Math.floor(((($47)>>>0))/(2)); + var $49=(($44)>>>0) < (($48)>>>0); + if ($49) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $51=$2; + var $52=(($51+96)|0); + var $53=HEAP32[(($52)>>2)]; + var $54=Math.floor(((($53)>>>0))/(2)); + HEAP32[(($52)>>2)]=$54; + var $55=$2; + var $56=(($55+92)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=(($57)|0); + var $59=_util_memory_a($58, 41, ((STRING_TABLE.__str)|0)); + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$2; + var $66=(($65+88)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$2; + var $69=(($68+92)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=(($70)|0); + assert($71 % 1 === 0, 'memcpy given ' + $71 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $67, $71, 1); + var $72=$2; + var $73=(($72+88)|0); + var $74=HEAP32[(($73)>>2)]; + _util_memory_d($74, 41, ((STRING_TABLE.__str)|0)); + var $75=$reall; + var $76=$2; + var $77=(($76+88)|0); + HEAP32[(($77)>>2)]=$75; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $80=$1; + ; + return $80; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_entitypool_remove["X"]=1; + +function _qc_program_entitypool_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + var $4=(($f)&1); + $3=$4; + var $5=$2; + var $6=(($5+92)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$2; + var $9=(($8+96)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)|0)==(($10)|0); + if ($11) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $13=$2; + var $14=(($13+96)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15)|0)!=0; + if ($16) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $18=$2; + var $19=(($18+96)|0); + HEAP32[(($19)>>2)]=16; + __label__ = 6; break; + case 5: + var $21=$2; + var $22=(($21+96)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=((($23<<1))|0); + HEAP32[(($22)>>2)]=$24; + __label__ = 6; break; + case 6: + var $26=$2; + var $27=(($26+96)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28)|0); + var $30=_util_memory_a($29, 41, ((STRING_TABLE.__str)|0)); + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$2; + var $37=(($36+88)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=$2; + var $40=(($39+92)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=(($41)|0); + assert($42 % 1 === 0, 'memcpy given ' + $42 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($35, $38, $42, 1); + var $43=$2; + var $44=(($43+88)|0); + var $45=HEAP32[(($44)>>2)]; + _util_memory_d($45, 41, ((STRING_TABLE.__str)|0)); + var $46=$reall; + var $47=$2; + var $48=(($47+88)|0); + HEAP32[(($48)>>2)]=$46; + __label__ = 9; break; + case 9: + var $50=$3; + var $51=(($50) & 1); + var $52=$2; + var $53=(($52+92)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=((($54)+(1))|0); + HEAP32[(($53)>>2)]=$55; + var $56=$2; + var $57=(($56+88)|0); + var $58=HEAP32[(($57)>>2)]; + var $59=(($58+$54)|0); + var $60=(($51)&1); + HEAP8[($59)]=$60; + $1=1; + __label__ = 10; break; + case 10: + var $62=$1; + ; + return $62; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_entitypool_add["X"]=1; + +function _qc_program_localstack_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+156)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+156)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+152)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+152)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+156)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+156)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+156)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+160)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+156)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 43, ((STRING_TABLE.__str)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+152)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+156)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+152)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 43, ((STRING_TABLE.__str)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+152)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_localstack_remove["X"]=1; + +function _qc_program_localstack_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+156)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+160)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+160)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+160)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+160)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+160)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 43, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+152)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+156)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+152)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 43, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+152)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+156)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+152)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_localstack_add["X"]=1; + +function _qc_program_localstack_append($s, $p, $c) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $reall; + var $oldalloc; + $2=$s; + $3=$p; + $4=$c; + var $5=$2; + var $6=(($5+156)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=$4; + var $9=((($7)+($8))|0); + var $10=$2; + var $11=(($10+160)|0); + var $12=HEAP32[(($11)>>2)]; + var $13=(($9)>>>0) > (($12)>>>0); + if ($13) { __label__ = 3; break; } else { __label__ = 14; break; } + case 3: + var $15=$2; + var $16=(($15+160)|0); + var $17=HEAP32[(($16)>>2)]; + var $18=(($17)|0)!=0; + if ($18) { __label__ = 8; break; } else { __label__ = 4; break; } + case 4: + var $20=$4; + var $21=(($20)>>>0) < 16; + if ($21) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $26 = 16;__label__ = 7; break; + case 6: + var $24=$4; + var $26 = $24;__label__ = 7; break; + case 7: + var $26; + var $27=$2; + var $28=(($27+160)|0); + HEAP32[(($28)>>2)]=$26; + var $29=$2; + var $30=(($29+160)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=((($31<<2))|0); + var $33=_util_memory_a($32, 44, ((STRING_TABLE.__str)|0)); + var $34=$33; + var $35=$2; + var $36=(($35+152)|0); + HEAP32[(($36)>>2)]=$34; + __label__ = 13; break; + case 8: + var $38=$2; + var $39=(($38+160)|0); + var $40=HEAP32[(($39)>>2)]; + $oldalloc=$40; + var $41=$2; + var $42=(($41+160)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<1))|0); + HEAP32[(($42)>>2)]=$44; + var $45=$2; + var $46=(($45+156)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$4; + var $49=((($47)+($48))|0); + var $50=$2; + var $51=(($50+160)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($49)>>>0) >= (($52)>>>0); + if ($53) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $55=$2; + var $56=(($55+156)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=$4; + var $59=((($57)+($58))|0); + var $60=$2; + var $61=(($60+160)|0); + HEAP32[(($61)>>2)]=$59; + __label__ = 10; break; + case 10: + var $63=$2; + var $64=(($63+160)|0); + var $65=HEAP32[(($64)>>2)]; + var $66=((($65<<2))|0); + var $67=_util_memory_a($66, 44, ((STRING_TABLE.__str)|0)); + var $68=$67; + $reall=$68; + var $69=$reall; + var $70=(($69)|0)!=0; + if ($70) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + var $72=$oldalloc; + var $73=$2; + var $74=(($73+160)|0); + HEAP32[(($74)>>2)]=$72; + $1=0; + __label__ = 15; break; + case 12: + var $76=$reall; + var $77=$76; + var $78=$2; + var $79=(($78+152)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=$80; + var $82=$2; + var $83=(($82+156)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=((($84<<2))|0); + assert($85 % 1 === 0, 'memcpy given ' + $85 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($77, $81, $85, 4); + var $86=$2; + var $87=(($86+152)|0); + var $88=HEAP32[(($87)>>2)]; + var $89=$88; + _util_memory_d($89, 44, ((STRING_TABLE.__str)|0)); + var $90=$reall; + var $91=$2; + var $92=(($91+152)|0); + HEAP32[(($92)>>2)]=$90; + __label__ = 13; break; + case 13: + __label__ = 14; break; + case 14: + var $95=$2; + var $96=(($95+156)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=$2; + var $99=(($98+152)|0); + var $100=HEAP32[(($99)>>2)]; + var $101=(($100+($97<<2))|0); + var $102=$101; + var $103=$3; + var $104=$103; + var $105=$4; + var $106=((($105<<2))|0); + assert($106 % 1 === 0, 'memcpy given ' + $106 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($102, $104, $106, 4); + var $107=$4; + var $108=$2; + var $109=(($108+156)|0); + var $110=HEAP32[(($109)>>2)]; + var $111=((($110)+($107))|0); + HEAP32[(($109)>>2)]=$111; + $1=1; + __label__ = 15; break; + case 15: + var $113=$1; + ; + return $113; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_localstack_append["X"]=1; + +function _qc_program_localstack_resize($s, $c) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$s; + $3=$c; + var $4=$3; + var $5=$2; + var $6=(($5+160)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) > (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $10=$3; + var $11=((($10<<2))|0); + var $12=_util_memory_a($11, 45, ((STRING_TABLE.__str)|0)); + var $13=$12; + $reall=$13; + var $14=$reall; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 11; break; + case 5: + var $18=$reall; + var $19=$18; + var $20=$2; + var $21=(($20+152)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=$22; + var $24=$2; + var $25=(($24+156)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26<<2))|0); + assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4); + var $28=$3; + var $29=$2; + var $30=(($29+160)|0); + HEAP32[(($30)>>2)]=$28; + var $31=$3; + var $32=$2; + var $33=(($32+156)|0); + HEAP32[(($33)>>2)]=$31; + var $34=$2; + var $35=(($34+152)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=$36; + _util_memory_d($37, 45, ((STRING_TABLE.__str)|0)); + var $38=$reall; + var $39=$2; + var $40=(($39+152)|0); + HEAP32[(($40)>>2)]=$38; + $1=1; + __label__ = 11; break; + case 6: + var $42=$3; + var $43=$2; + var $44=(($43+156)|0); + HEAP32[(($44)>>2)]=$42; + var $45=$3; + var $46=$2; + var $47=(($46+160)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=Math.floor(((($48)>>>0))/(2)); + var $50=(($45)>>>0) < (($49)>>>0); + if ($50) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $52=$3; + var $53=((($52<<2))|0); + var $54=_util_memory_a($53, 45, ((STRING_TABLE.__str)|0)); + var $55=$54; + $reall=$55; + var $56=$reall; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 11; break; + case 9: + var $60=$reall; + var $61=$60; + var $62=$2; + var $63=(($62+152)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=$64; + var $66=$3; + var $67=((($66<<2))|0); + assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4); + var $68=$2; + var $69=(($68+152)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$70; + _util_memory_d($71, 45, ((STRING_TABLE.__str)|0)); + var $72=$reall; + var $73=$2; + var $74=(($73+152)|0); + HEAP32[(($74)>>2)]=$72; + var $75=$3; + var $76=$2; + var $77=(($76+160)|0); + HEAP32[(($77)>>2)]=$75; + __label__ = 10; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $80=$1; + ; + return $80; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_localstack_resize["X"]=1; + +function _qc_program_stack_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+168)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+168)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=$2; + var $22=(($21+164)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=(($23+($20)*(12))|0); + var $25=$i; + var $26=((($25)+(1))|0); + var $27=$2; + var $28=(($27+164)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29+($26)*(12))|0); + var $31=$24; + var $32=$30; + 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)]; + __label__ = 7; break; + case 7: + var $34=$i; + var $35=((($34)+(1))|0); + $i=$35; + __label__ = 5; break; + case 8: + var $37=$2; + var $38=(($37+168)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=((($39)-(1))|0); + HEAP32[(($38)>>2)]=$40; + var $41=$2; + var $42=(($41+168)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=$2; + var $45=(($44+168)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=Math.floor(((($46)>>>0))/(2)); + var $48=(($43)>>>0) < (($47)>>>0); + if ($48) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $50=$2; + var $51=(($50+172)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=Math.floor(((($52)>>>0))/(2)); + HEAP32[(($51)>>2)]=$53; + var $54=$2; + var $55=(($54+168)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)*(12))|0); + var $58=_util_memory_a($57, 46, ((STRING_TABLE.__str)|0)); + var $59=$58; + $reall=$59; + var $60=$reall; + var $61=(($60)|0)!=0; + if ($61) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $64=$reall; + var $65=$64; + var $66=$2; + var $67=(($66+164)|0); + var $68=HEAP32[(($67)>>2)]; + var $69=$68; + var $70=$2; + var $71=(($70+168)|0); + var $72=HEAP32[(($71)>>2)]; + var $73=((($72)*(12))|0); + assert($73 % 1 === 0, 'memcpy given ' + $73 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($65, $69, $73, 4); + var $74=$2; + var $75=(($74+164)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=$76; + _util_memory_d($77, 46, ((STRING_TABLE.__str)|0)); + var $78=$reall; + var $79=$2; + var $80=(($79+164)|0); + HEAP32[(($80)>>2)]=$78; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $83=$1; + ; + return $83; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_stack_remove["X"]=1; + +function _qc_program_stack_add($self, $f_0, $f_1, $f_2) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $f=__stackBase__; + var $reall; + $2=$self; + var $3=(($f)|0); + HEAP32[(($3)>>2)]=$f_0; + var $4=(($f+4)|0); + HEAP32[(($4)>>2)]=$f_1; + var $5=(($f+8)|0); + HEAP32[(($5)>>2)]=$f_2; + var $6=$2; + var $7=(($6+168)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=$2; + var $10=(($9+172)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=(($8)|0)==(($11)|0); + if ($12) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $14=$2; + var $15=(($14+172)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=(($16)|0)!=0; + if ($17) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $19=$2; + var $20=(($19+172)|0); + HEAP32[(($20)>>2)]=16; + __label__ = 6; break; + case 5: + var $22=$2; + var $23=(($22+172)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=((($24<<1))|0); + HEAP32[(($23)>>2)]=$25; + __label__ = 6; break; + case 6: + var $27=$2; + var $28=(($27+172)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=((($29)*(12))|0); + var $31=_util_memory_a($30, 46, ((STRING_TABLE.__str)|0)); + var $32=$31; + $reall=$32; + var $33=$reall; + var $34=(($33)|0)!=0; + if ($34) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $37=$reall; + var $38=$37; + var $39=$2; + var $40=(($39+164)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$41; + var $43=$2; + var $44=(($43+168)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=((($45)*(12))|0); + assert($46 % 1 === 0, 'memcpy given ' + $46 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($38, $42, $46, 4); + var $47=$2; + var $48=(($47+164)|0); + var $49=HEAP32[(($48)>>2)]; + var $50=$49; + _util_memory_d($50, 46, ((STRING_TABLE.__str)|0)); + var $51=$reall; + var $52=$2; + var $53=(($52+164)|0); + HEAP32[(($53)>>2)]=$51; + __label__ = 9; break; + case 9: + var $55=$2; + var $56=(($55+168)|0); + var $57=HEAP32[(($56)>>2)]; + var $58=((($57)+(1))|0); + HEAP32[(($56)>>2)]=$58; + var $59=$2; + var $60=(($59+164)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61+($57)*(12))|0); + var $63=$62; + var $64=$f; + 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)]; + $1=1; + __label__ = 10; break; + case 10: + var $66=$1; + STACKTOP = __stackBase__; + return $66; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_stack_add["X"]=1; + +function _qc_program_profile_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+120)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+120)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+116)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+116)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+120)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+120)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+120)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+124)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+120)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 48, ((STRING_TABLE.__str)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+116)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+120)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+116)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 48, ((STRING_TABLE.__str)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+116)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_profile_remove["X"]=1; + +function _qc_program_profile_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+120)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+124)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+124)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+124)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+124)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+124)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 48, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+116)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+120)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+116)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 48, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+116)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+120)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+116)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_profile_add["X"]=1; + +function _qc_program_profile_resize($s, $c) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$s; + $3=$c; + var $4=$3; + var $5=$2; + var $6=(($5+124)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) > (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $10=$3; + var $11=((($10<<2))|0); + var $12=_util_memory_a($11, 49, ((STRING_TABLE.__str)|0)); + var $13=$12; + $reall=$13; + var $14=$reall; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + $1=0; + __label__ = 11; break; + case 5: + var $18=$reall; + var $19=$18; + var $20=$2; + var $21=(($20+116)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=$22; + var $24=$2; + var $25=(($24+120)|0); + var $26=HEAP32[(($25)>>2)]; + var $27=((($26<<2))|0); + assert($27 % 1 === 0, 'memcpy given ' + $27 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($19, $23, $27, 4); + var $28=$3; + var $29=$2; + var $30=(($29+124)|0); + HEAP32[(($30)>>2)]=$28; + var $31=$3; + var $32=$2; + var $33=(($32+120)|0); + HEAP32[(($33)>>2)]=$31; + var $34=$2; + var $35=(($34+116)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=$36; + _util_memory_d($37, 49, ((STRING_TABLE.__str)|0)); + var $38=$reall; + var $39=$2; + var $40=(($39+116)|0); + HEAP32[(($40)>>2)]=$38; + $1=1; + __label__ = 11; break; + case 6: + var $42=$3; + var $43=$2; + var $44=(($43+120)|0); + HEAP32[(($44)>>2)]=$42; + var $45=$3; + var $46=$2; + var $47=(($46+124)|0); + var $48=HEAP32[(($47)>>2)]; + var $49=Math.floor(((($48)>>>0))/(2)); + var $50=(($45)>>>0) < (($49)>>>0); + if ($50) { __label__ = 7; break; } else { __label__ = 10; break; } + case 7: + var $52=$3; + var $53=((($52<<2))|0); + var $54=_util_memory_a($53, 49, ((STRING_TABLE.__str)|0)); + var $55=$54; + $reall=$55; + var $56=$reall; + var $57=(($56)|0)!=0; + if ($57) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + $1=0; + __label__ = 11; break; + case 9: + var $60=$reall; + var $61=$60; + var $62=$2; + var $63=(($62+116)|0); + var $64=HEAP32[(($63)>>2)]; + var $65=$64; + var $66=$3; + var $67=((($66<<2))|0); + assert($67 % 1 === 0, 'memcpy given ' + $67 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($61, $65, $67, 4); + var $68=$2; + var $69=(($68+116)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$70; + _util_memory_d($71, 49, ((STRING_TABLE.__str)|0)); + var $72=$reall; + var $73=$2; + var $74=(($73+116)|0); + HEAP32[(($74)>>2)]=$72; + var $75=$3; + var $76=$2; + var $77=(($76+124)|0); + HEAP32[(($77)>>2)]=$75; + __label__ = 10; break; + case 10: + $1=1; + __label__ = 11; break; + case 11: + var $80=$1; + ; + return $80; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_profile_resize["X"]=1; + +function _qc_program_builtins_remove($self, $idx) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + var $reall; + $2=$self; + $3=$idx; + var $4=$3; + var $5=$2; + var $6=(($5+132)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)>>>0) >= (($7)>>>0); + if ($8) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + $1=1; + __label__ = 13; break; + case 4: + var $11=$3; + $i=$11; + __label__ = 5; break; + case 5: + var $13=$i; + var $14=$2; + var $15=(($14+132)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=((($16)-(1))|0); + var $18=(($13)>>>0) < (($17)>>>0); + if ($18) { __label__ = 6; break; } else { __label__ = 8; break; } + case 6: + var $20=$i; + var $21=((($20)+(1))|0); + var $22=$2; + var $23=(($22+128)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=(($24+($21<<2))|0); + var $26=HEAP32[(($25)>>2)]; + var $27=$i; + var $28=$2; + var $29=(($28+128)|0); + var $30=HEAP32[(($29)>>2)]; + var $31=(($30+($27<<2))|0); + HEAP32[(($31)>>2)]=$26; + __label__ = 7; break; + case 7: + var $33=$i; + var $34=((($33)+(1))|0); + $i=$34; + __label__ = 5; break; + case 8: + var $36=$2; + var $37=(($36+132)|0); + var $38=HEAP32[(($37)>>2)]; + var $39=((($38)-(1))|0); + HEAP32[(($37)>>2)]=$39; + var $40=$2; + var $41=(($40+132)|0); + var $42=HEAP32[(($41)>>2)]; + var $43=$2; + var $44=(($43+132)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=Math.floor(((($45)>>>0))/(2)); + var $47=(($42)>>>0) < (($46)>>>0); + if ($47) { __label__ = 9; break; } else { __label__ = 12; break; } + case 9: + var $49=$2; + var $50=(($49+136)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=Math.floor(((($51)>>>0))/(2)); + HEAP32[(($50)>>2)]=$52; + var $53=$2; + var $54=(($53+132)|0); + var $55=HEAP32[(($54)>>2)]; + var $56=((($55<<2))|0); + var $57=_util_memory_a($56, 51, ((STRING_TABLE.__str)|0)); + var $58=$57; + $reall=$58; + var $59=$reall; + var $60=(($59)|0)!=0; + if ($60) { __label__ = 11; break; } else { __label__ = 10; break; } + case 10: + $1=0; + __label__ = 13; break; + case 11: + var $63=$reall; + var $64=$63; + var $65=$2; + var $66=(($65+128)|0); + var $67=HEAP32[(($66)>>2)]; + var $68=$67; + var $69=$2; + var $70=(($69+132)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=((($71<<2))|0); + assert($72 % 1 === 0, 'memcpy given ' + $72 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($64, $68, $72, 4); + var $73=$2; + var $74=(($73+128)|0); + var $75=HEAP32[(($74)>>2)]; + var $76=$75; + _util_memory_d($76, 51, ((STRING_TABLE.__str)|0)); + var $77=$reall; + var $78=$2; + var $79=(($78+128)|0); + HEAP32[(($79)>>2)]=$77; + __label__ = 12; break; + case 12: + $1=1; + __label__ = 13; break; + case 13: + var $82=$1; + ; + return $82; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_builtins_remove["X"]=1; + +function _qc_program_builtins_add($self, $f) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $reall; + $2=$self; + $3=$f; + var $4=$2; + var $5=(($4+132)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=$2; + var $8=(($7+136)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($6)|0)==(($9)|0); + if ($10) { __label__ = 3; break; } else { __label__ = 9; break; } + case 3: + var $12=$2; + var $13=(($12+136)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14)|0)!=0; + if ($15) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + var $17=$2; + var $18=(($17+136)|0); + HEAP32[(($18)>>2)]=16; + __label__ = 6; break; + case 5: + var $20=$2; + var $21=(($20+136)|0); + var $22=HEAP32[(($21)>>2)]; + var $23=((($22<<1))|0); + HEAP32[(($21)>>2)]=$23; + __label__ = 6; break; + case 6: + var $25=$2; + var $26=(($25+136)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=((($27<<2))|0); + var $29=_util_memory_a($28, 51, ((STRING_TABLE.__str)|0)); + var $30=$29; + $reall=$30; + var $31=$reall; + var $32=(($31)|0)!=0; + if ($32) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + $1=0; + __label__ = 10; break; + case 8: + var $35=$reall; + var $36=$35; + var $37=$2; + var $38=(($37+128)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$39; + var $41=$2; + var $42=(($41+132)|0); + var $43=HEAP32[(($42)>>2)]; + var $44=((($43<<2))|0); + assert($44 % 1 === 0, 'memcpy given ' + $44 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($36, $40, $44, 4); + var $45=$2; + var $46=(($45+128)|0); + var $47=HEAP32[(($46)>>2)]; + var $48=$47; + _util_memory_d($48, 51, ((STRING_TABLE.__str)|0)); + var $49=$reall; + var $50=$2; + var $51=(($50+128)|0); + HEAP32[(($51)>>2)]=$49; + __label__ = 9; break; + case 9: + var $53=$3; + var $54=$2; + var $55=(($54+132)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+(1))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$2; + var $59=(($58+128)|0); + var $60=HEAP32[(($59)>>2)]; + var $61=(($60+($56<<2))|0); + HEAP32[(($61)>>2)]=$53; + $1=1; + __label__ = 10; break; + case 10: + var $63=$1; + ; + return $63; + default: assert(0, "bad label: " + __label__); + } +} +_qc_program_builtins_add["X"]=1; + +function _prog_load($filename) { + var __stackBase__ = STACKTOP; STACKTOP += 60; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $prog; + var $header=__stackBase__; + var $i; + var $file; + $2=$filename; + var $3=$2; + var $4=_util_fopen($3, ((STRING_TABLE.__str1)|0)); + $file=$4; + var $5=$file; + var $6=(($5)|0)!=0; + if ($6) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + $1=0; + __label__ = 80; break; + case 4: + var $9=$header; + var $10=$file; + var $11=_fread($9, 60, 1, $10); + var $12=(($11)|0)!=1; + if ($12) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $14=$2; + _loaderror(((STRING_TABLE.__str2)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$14,tempInt)); + var $15=$file; + var $16=_fclose($15); + $1=0; + __label__ = 80; break; + case 6: + var $18=(($header)|0); + var $19=HEAP32[(($18)>>2)]; + var $20=(($19)|0)!=6; + if ($20) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $22=(($header)|0); + var $23=HEAP32[(($22)>>2)]; + _loaderror(((STRING_TABLE.__str3)|0), (tempInt=STACKTOP,STACKTOP += 4,assert(STACKTOP < STACK_ROOT + STACK_MAX, "Ran out of stack"),HEAP32[((tempInt)>>2)]=$23,tempInt)); + var $24=$file; + var $25=_fclose($24); + $1=0; + __label__ = 80; break; + case 8: + var $27=_util_memory_a(188, 98, ((STRING_TABLE.__str)|0)); + var $28=$27; + $prog=$28; + var $29=$prog; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $32=$file; + var $33=_fclose($32); + 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)); + $1=0; + __label__ = 80; break; + case 10: + var $36=$prog; + var $37=$36; + for (var $$dest = $37>>2, $$stop = $$dest + 47; $$dest < $$stop; $$dest++) { + HEAP32[$$dest] = 0 + }; + var $38=(($header+56)|0); + var $39=HEAP32[(($38)>>2)]; + var $40=$prog; + var $41=(($40+144)|0); + HEAP32[(($41)>>2)]=$39; + var $42=(($header+4)|0); + var $43=HEAP16[(($42)>>1)]; + var $44=$prog; + var $45=(($44+100)|0); + HEAP16[(($45)>>1)]=$43; + var $46=$2; + var $47=_util_strdup($46); + var $48=$prog; + var $49=(($48)|0); + HEAP32[(($49)>>2)]=$47; + var $50=$prog; + var $51=(($50)|0); + var $52=HEAP32[(($51)>>2)]; + var $53=(($52)|0)!=0; + if ($53) { __label__ = 12; break; } else { __label__ = 11; break; } + case 11: + _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)); + __label__ = 61; break; + case 12: + var $56=$file; + var $57=(($header+8)|0); + var $58=(($57)|0); + var $59=HEAP32[(($58)>>2)]; + var $60=_fseek($56, $59, 0); + var $61=(($60)|0)!=0; + if ($61) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + _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)); + __label__ = 61; break; + case 14: + var $64=(($header+8)|0); + var $65=(($64+4)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=$prog; + var $68=(($67+12)|0); + HEAP32[(($68)>>2)]=$66; + var $69=(($header+8)|0); + var $70=(($69+4)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$prog; + var $73=(($72+8)|0); + HEAP32[(($73)>>2)]=$71; + var $74=(($header+8)|0); + var $75=(($74+4)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=((($76<<3))|0); + var $78=_util_memory_a($77, 132, ((STRING_TABLE.__str)|0)); + var $79=$78; + var $80=$prog; + var $81=(($80+4)|0); + HEAP32[(($81)>>2)]=$79; + var $82=$prog; + var $83=(($82+4)|0); + var $84=HEAP32[(($83)>>2)]; + var $85=(($84)|0)!=0; + if ($85) { __label__ = 16; break; } else { __label__ = 15; break; } + case 15: + __label__ = 61; break; + case 16: + var $88=$prog; + var $89=(($88+4)|0); + var $90=HEAP32[(($89)>>2)]; + var $91=$90; + var $92=(($header+8)|0); + var $93=(($92+4)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=$file; + var $96=_fread($91, 8, $94, $95); + var $97=(($header+8)|0); + var $98=(($97+4)|0); + var $99=HEAP32[(($98)>>2)]; + var $100=(($96)|0)!=(($99)|0); + if ($100) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + _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)); + __label__ = 61; break; + case 18: + var $103=$file; + var $104=(($header+16)|0); + var $105=(($104)|0); + var $106=HEAP32[(($105)>>2)]; + var $107=_fseek($103, $106, 0); + var $108=(($107)|0)!=0; + if ($108) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + _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)); + __label__ = 61; break; + case 20: + var $111=(($header+16)|0); + var $112=(($111+4)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$prog; + var $115=(($114+24)|0); + HEAP32[(($115)>>2)]=$113; + var $116=(($header+16)|0); + var $117=(($116+4)|0); + var $118=HEAP32[(($117)>>2)]; + var $119=$prog; + var $120=(($119+20)|0); + HEAP32[(($120)>>2)]=$118; + var $121=(($header+16)|0); + var $122=(($121+4)|0); + var $123=HEAP32[(($122)>>2)]; + var $124=((($123<<3))|0); + var $125=_util_memory_a($124, 133, ((STRING_TABLE.__str)|0)); + var $126=$125; + var $127=$prog; + var $128=(($127+16)|0); + HEAP32[(($128)>>2)]=$126; + var $129=$prog; + var $130=(($129+16)|0); + var $131=HEAP32[(($130)>>2)]; + var $132=(($131)|0)!=0; + if ($132) { __label__ = 22; break; } else { __label__ = 21; break; } + case 21: + __label__ = 61; break; + case 22: + var $135=$prog; + var $136=(($135+16)|0); + var $137=HEAP32[(($136)>>2)]; + var $138=$137; + var $139=(($header+16)|0); + var $140=(($139+4)|0); + var $141=HEAP32[(($140)>>2)]; + var $142=$file; + var $143=_fread($138, 8, $141, $142); + var $144=(($header+16)|0); + var $145=(($144+4)|0); + var $146=HEAP32[(($145)>>2)]; + var $147=(($143)|0)!=(($146)|0); + if ($147) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + _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)); + __label__ = 61; break; + case 24: + var $150=$file; + var $151=(($header+24)|0); + var $152=(($151)|0); + var $153=HEAP32[(($152)>>2)]; + var $154=_fseek($150, $153, 0); + var $155=(($154)|0)!=0; + if ($155) { __label__ = 25; break; } else { __label__ = 26; break; } + case 25: + _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)); + __label__ = 61; break; + case 26: + var $158=(($header+24)|0); + var $159=(($158+4)|0); + var $160=HEAP32[(($159)>>2)]; + var $161=$prog; + var $162=(($161+36)|0); + HEAP32[(($162)>>2)]=$160; + var $163=(($header+24)|0); + var $164=(($163+4)|0); + var $165=HEAP32[(($164)>>2)]; + var $166=$prog; + var $167=(($166+32)|0); + HEAP32[(($167)>>2)]=$165; + var $168=(($header+24)|0); + var $169=(($168+4)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=((($170<<3))|0); + var $172=_util_memory_a($171, 134, ((STRING_TABLE.__str)|0)); + var $173=$172; + var $174=$prog; + var $175=(($174+28)|0); + HEAP32[(($175)>>2)]=$173; + var $176=$prog; + var $177=(($176+28)|0); + var $178=HEAP32[(($177)>>2)]; + var $179=(($178)|0)!=0; + if ($179) { __label__ = 28; break; } else { __label__ = 27; break; } + case 27: + __label__ = 61; break; + case 28: + var $182=$prog; + var $183=(($182+28)|0); + var $184=HEAP32[(($183)>>2)]; + var $185=$184; + var $186=(($header+24)|0); + var $187=(($186+4)|0); + var $188=HEAP32[(($187)>>2)]; + var $189=$file; + var $190=_fread($185, 8, $188, $189); + var $191=(($header+24)|0); + var $192=(($191+4)|0); + var $193=HEAP32[(($192)>>2)]; + var $194=(($190)|0)!=(($193)|0); + if ($194) { __label__ = 29; break; } else { __label__ = 30; break; } + case 29: + _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)); + __label__ = 61; break; + case 30: + var $197=$file; + var $198=(($header+32)|0); + var $199=(($198)|0); + var $200=HEAP32[(($199)>>2)]; + var $201=_fseek($197, $200, 0); + var $202=(($201)|0)!=0; + if ($202) { __label__ = 31; break; } else { __label__ = 32; break; } + case 31: + _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)); + __label__ = 61; break; + case 32: + var $205=(($header+32)|0); + var $206=(($205+4)|0); + var $207=HEAP32[(($206)>>2)]; + var $208=$prog; + var $209=(($208+48)|0); + HEAP32[(($209)>>2)]=$207; + var $210=(($header+32)|0); + var $211=(($210+4)|0); + var $212=HEAP32[(($211)>>2)]; + var $213=$prog; + var $214=(($213+44)|0); + HEAP32[(($214)>>2)]=$212; + var $215=(($header+32)|0); + var $216=(($215+4)|0); + var $217=HEAP32[(($216)>>2)]; + var $218=((($217)*(36))|0); + var $219=_util_memory_a($218, 135, ((STRING_TABLE.__str)|0)); + var $220=$219; + var $221=$prog; + var $222=(($221+40)|0); + HEAP32[(($222)>>2)]=$220; + var $223=$prog; + var $224=(($223+40)|0); + var $225=HEAP32[(($224)>>2)]; + var $226=(($225)|0)!=0; + if ($226) { __label__ = 34; break; } else { __label__ = 33; break; } + case 33: + __label__ = 61; break; + case 34: + var $229=$prog; + var $230=(($229+40)|0); + var $231=HEAP32[(($230)>>2)]; + var $232=$231; + var $233=(($header+32)|0); + var $234=(($233+4)|0); + var $235=HEAP32[(($234)>>2)]; + var $236=$file; + var $237=_fread($232, 36, $235, $236); + var $238=(($header+32)|0); + var $239=(($238+4)|0); + var $240=HEAP32[(($239)>>2)]; + var $241=(($237)|0)!=(($240)|0); + if ($241) { __label__ = 35; break; } else { __label__ = 36; break; } + case 35: + _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)); + __label__ = 61; break; + case 36: + var $244=$file; + var $245=(($header+40)|0); + var $246=(($245)|0); + var $247=HEAP32[(($246)>>2)]; + var $248=_fseek($244, $247, 0); + var $249=(($248)|0)!=0; + if ($249) { __label__ = 37; break; } else { __label__ = 38; break; } + case 37: + _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)); + __label__ = 61; break; + case 38: + var $252=(($header+40)|0); + var $253=(($252+4)|0); + var $254=HEAP32[(($253)>>2)]; + var $255=$prog; + var $256=(($255+60)|0); + HEAP32[(($256)>>2)]=$254; + var $257=(($header+40)|0); + var $258=(($257+4)|0); + var $259=HEAP32[(($258)>>2)]; + var $260=$prog; + var $261=(($260+56)|0); + HEAP32[(($261)>>2)]=$259; + var $262=(($header+40)|0); + var $263=(($262+4)|0); + var $264=HEAP32[(($263)>>2)]; + var $265=(($264)|0); + var $266=_util_memory_a($265, 136, ((STRING_TABLE.__str)|0)); + var $267=$prog; + var $268=(($267+52)|0); + HEAP32[(($268)>>2)]=$266; + var $269=$prog; + var $270=(($269+52)|0); + var $271=HEAP32[(($270)>>2)]; + var $272=(($271)|0)!=0; + if ($272) { __label__ = 40; break; } else { __label__ = 39; break; } + case 39: + __label__ = 61; break; + case 40: + var $275=$prog; + var $276=(($275+52)|0); + var $277=HEAP32[(($276)>>2)]; + var $278=(($header+40)|0); + var $279=(($278+4)|0); + var $280=HEAP32[(($279)>>2)]; + var $281=$file; + var $282=_fread($277, 1, $280, $281); + var $283=(($header+40)|0); + var $284=(($283+4)|0); + var $285=HEAP32[(($284)>>2)]; + var $286=(($282)|0)!=(($285)|0); + if ($286) { __label__ = 41; break; } else { __label__ = 42; break; } + case 41: + _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)); + __label__ = 61; break; + case 42: + var $289=$file; + var $290=(($header+48)|0); + var $291=(($290)|0); + var $292=HEAP32[(($291)>>2)]; + var $293=_fseek($289, $292, 0); + var $294=(($293)|0)!=0; + if ($294) { __label__ = 43; break; } else { __label__ = 44; break; } + case 43: + _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)); + __label__ = 61; break; + case 44: + var $297=(($header+48)|0); + var $298=(($297+4)|0); + var $299=HEAP32[(($298)>>2)]; + var $300=$prog; + var $301=(($300+72)|0); + HEAP32[(($301)>>2)]=$299; + var $302=(($header+48)|0); + var $303=(($302+4)|0); + var $304=HEAP32[(($303)>>2)]; + var $305=$prog; + var $306=(($305+68)|0); + HEAP32[(($306)>>2)]=$304; + var $307=(($header+48)|0); + var $308=(($307+4)|0); + var $309=HEAP32[(($308)>>2)]; + var $310=((($309<<2))|0); + var $311=_util_memory_a($310, 137, ((STRING_TABLE.__str)|0)); + var $312=$311; + var $313=$prog; + var $314=(($313+64)|0); + HEAP32[(($314)>>2)]=$312; + var $315=$prog; + var $316=(($315+64)|0); + var $317=HEAP32[(($316)>>2)]; + var $318=(($317)|0)!=0; + if ($318) { __label__ = 46; break; } else { __label__ = 45; break; } + case 45: + __label__ = 61; break; + case 46: + var $321=$prog; + var $322=(($321+64)|0); + var $323=HEAP32[(($322)>>2)]; + var $324=$323; + var $325=(($header+48)|0); + var $326=(($325+4)|0); + var $327=HEAP32[(($326)>>2)]; + var $328=$file; + var $329=_fread($324, 4, $327, $328); + var $330=(($header+48)|0); + var $331=(($330+4)|0); + var $332=HEAP32[(($331)>>2)]; + var $333=(($329)|0)!=(($332)|0); + if ($333) { __label__ = 47; break; } else { __label__ = 48; break; } + case 47: + _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)); + __label__ = 61; break; + case 48: + var $336=$file; + var $337=_fclose($336); + var $338=$prog; + var $339=$prog; + var $340=(($339+8)|0); + var $341=HEAP32[(($340)>>2)]; + var $342=_qc_program_profile_resize($338, $341); + if ($342) { __label__ = 50; break; } else { __label__ = 49; break; } + case 49: + __label__ = 61; break; + case 50: + var $345=$prog; + var $346=(($345+56)|0); + var $347=HEAP32[(($346)>>2)]; + var $348=$prog; + var $349=(($348+104)|0); + HEAP32[(($349)>>2)]=$347; + var $350=$prog; + var $351=(($350+56)|0); + var $352=HEAP32[(($351)>>2)]; + var $353=$prog; + var $354=(($353+108)|0); + HEAP32[(($354)>>2)]=$352; + var $355=$prog; + var $356=$prog; + var $357=(($356+56)|0); + var $358=HEAP32[(($357)>>2)]; + var $359=((($358)+(16384))|0); + var $360=_qc_program_strings_resize($355, $359); + if ($360) { __label__ = 52; break; } else { __label__ = 51; break; } + case 51: + __label__ = 61; break; + case 52: + var $363=$prog; + var $364=_qc_program_entitypool_add($363, 1); + if ($364) { __label__ = 54; break; } else { __label__ = 53; break; } + case 53: + _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)); + __label__ = 61; break; + case 54: + $i=0; + __label__ = 55; break; + case 55: + var $368=$i; + var $369=$prog; + var $370=(($369+144)|0); + var $371=HEAP32[(($370)>>2)]; + var $372=(($368)>>>0) < (($371)>>>0); + if ($372) { __label__ = 56; break; } else { __label__ = 60; break; } + case 56: + var $374=$prog; + var $375=_qc_program_entitydata_add($374, 0); + if ($375) { __label__ = 58; break; } else { __label__ = 57; break; } + case 57: + _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)); + __label__ = 61; break; + case 58: + __label__ = 59; break; + case 59: + var $379=$i; + var $380=((($379)+(1))|0); + $i=$380; + __label__ = 55; break; + case 60: + var $382=$prog; + var $383=(($382+140)|0); + HEAP32[(($383)>>2)]=1; + var $384=$prog; + $1=$384; + __label__ = 80; break; + case 61: + var $386=$prog; + var $387=(($386)|0); + var $388=HEAP32[(($387)>>2)]; + var $389=(($388)|0)!=0; + if ($389) { __label__ = 62; break; } else { __label__ = 63; break; } + case 62: + var $391=$prog; + var $392=(($391)|0); + var $393=HEAP32[(($392)>>2)]; + _util_memory_d($393, 167, ((STRING_TABLE.__str)|0)); + __label__ = 63; break; + case 63: + var $395=$prog; + var $396=(($395+4)|0); + var $397=HEAP32[(($396)>>2)]; + var $398=(($397)|0)!=0; + if ($398) { __label__ = 64; break; } else { __label__ = 65; break; } + case 64: + var $400=$prog; + var $401=(($400+4)|0); + var $402=HEAP32[(($401)>>2)]; + var $403=$402; + _util_memory_d($403, 168, ((STRING_TABLE.__str)|0)); + __label__ = 65; break; + case 65: + var $405=$prog; + var $406=(($405+16)|0); + var $407=HEAP32[(($406)>>2)]; + var $408=(($407)|0)!=0; + if ($408) { __label__ = 66; break; } else { __label__ = 67; break; } + case 66: + var $410=$prog; + var $411=(($410+16)|0); + var $412=HEAP32[(($411)>>2)]; + var $413=$412; + _util_memory_d($413, 169, ((STRING_TABLE.__str)|0)); + __label__ = 67; break; + case 67: + var $415=$prog; + var $416=(($415+28)|0); + var $417=HEAP32[(($416)>>2)]; + var $418=(($417)|0)!=0; + if ($418) { __label__ = 68; break; } else { __label__ = 69; break; } + case 68: + var $420=$prog; + var $421=(($420+28)|0); + var $422=HEAP32[(($421)>>2)]; + var $423=$422; + _util_memory_d($423, 170, ((STRING_TABLE.__str)|0)); + __label__ = 69; break; + case 69: + var $425=$prog; + var $426=(($425+40)|0); + var $427=HEAP32[(($426)>>2)]; + var $428=(($427)|0)!=0; + if ($428) { __label__ = 70; break; } else { __label__ = 71; break; } + case 70: + var $430=$prog; + var $431=(($430+40)|0); + var $432=HEAP32[(($431)>>2)]; + var $433=$432; + _util_memory_d($433, 171, ((STRING_TABLE.__str)|0)); + __label__ = 71; break; + case 71: + var $435=$prog; + var $436=(($435+52)|0); + var $437=HEAP32[(($436)>>2)]; + var $438=(($437)|0)!=0; + if ($438) { __label__ = 72; break; } else { __label__ = 73; break; } + case 72: + var $440=$prog; + var $441=(($440+52)|0); + var $442=HEAP32[(($441)>>2)]; + _util_memory_d($442, 172, ((STRING_TABLE.__str)|0)); + __label__ = 73; break; + case 73: + var $444=$prog; + var $445=(($444+64)|0); + var $446=HEAP32[(($445)>>2)]; + var $447=(($446)|0)!=0; + if ($447) { __label__ = 74; break; } else { __label__ = 75; break; } + case 74: + var $449=$prog; + var $450=(($449+64)|0); + var $451=HEAP32[(($450)>>2)]; + var $452=$451; + _util_memory_d($452, 173, ((STRING_TABLE.__str)|0)); + __label__ = 75; break; + case 75: + var $454=$prog; + var $455=(($454+76)|0); + var $456=HEAP32[(($455)>>2)]; + var $457=(($456)|0)!=0; + if ($457) { __label__ = 76; break; } else { __label__ = 77; break; } + case 76: + var $459=$prog; + var $460=(($459+76)|0); + var $461=HEAP32[(($460)>>2)]; + var $462=$461; + _util_memory_d($462, 174, ((STRING_TABLE.__str)|0)); + __label__ = 77; break; + case 77: + var $464=$prog; + var $465=(($464+88)|0); + var $466=HEAP32[(($465)>>2)]; + var $467=(($466)|0)!=0; + if ($467) { __label__ = 78; break; } else { __label__ = 79; break; } + case 78: + var $469=$prog; + var $470=(($469+88)|0); + var $471=HEAP32[(($470)>>2)]; + _util_memory_d($471, 175, ((STRING_TABLE.__str)|0)); + __label__ = 79; break; + case 79: + var $473=$prog; + var $474=$473; + _util_memory_d($474, 176, ((STRING_TABLE.__str)|0)); + $1=0; + __label__ = 80; break; + case 80: + var $476=$1; + STACKTOP = __stackBase__; + return $476; + default: assert(0, "bad label: " + __label__); + } +} +_prog_load["X"]=1; + +function _loaderror($fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $err; + var $ap=__stackBase__; + $1=$fmt; + var $2=___errno(); + var $3=HEAP32[(($2)>>2)]; + $err=$3; + var $4=$ap; + HEAP32[(($4)>>2)]=arguments[_loaderror.length]; + var $5=$1; + var $6=HEAP32[(($ap)>>2)]; + var $7=_vprintf($5, $6); + var $8=$ap; + ; + var $9=$err; + var $10=_strerror($9); + 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)); + STACKTOP = __stackBase__; + return; +} + + +function _prog_getstring($prog, $str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + $2=$prog; + $3=$str; + var $4=$3; + var $5=(($4)|0) < 0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $7=$3; + var $8=$2; + var $9=(($8+56)|0); + var $10=HEAP32[(($9)>>2)]; + var $11=(($7)>>>0) >= (($10)>>>0); + if ($11) { __label__ = 4; break; } else { __label__ = 5; break; } + case 4: + $1=((STRING_TABLE.__str10)|0); + __label__ = 6; break; + case 5: + var $14=$2; + var $15=(($14+52)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=$3; + var $18=(($16+$17)|0); + $1=$18; + __label__ = 6; break; + case 6: + var $20=$1; + ; + return $20; + default: assert(0, "bad label: " + __label__); + } +} + + +function _prog_entfield($prog, $off) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$prog; + $3=$off; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+32)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+28)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<3))|0); + var $16=(($15+2)|0); + var $17=HEAP16[(($16)>>1)]; + var $18=(($17)&65535); + var $19=$3; + var $20=(($18)|0)==(($19)|0); + if ($20) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $22=$2; + var $23=(($22+28)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$i; + var $26=(($24+($25<<3))|0); + $1=$26; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $29=$i; + var $30=((($29)+(1))|0); + $i=$30; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _prog_getdef($prog, $off) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $i; + $2=$prog; + $3=$off; + $i=0; + __label__ = 3; break; + case 3: + var $5=$i; + var $6=$2; + var $7=(($6+20)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($5)>>>0) < (($8)>>>0); + if ($9) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $11=$i; + var $12=$2; + var $13=(($12+16)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=(($14+($11<<3))|0); + var $16=(($15+2)|0); + var $17=HEAP16[(($16)>>1)]; + var $18=(($17)&65535); + var $19=$3; + var $20=(($18)|0)==(($19)|0); + if ($20) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $22=$2; + var $23=(($22+16)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=$i; + var $26=(($24+($25<<3))|0); + $1=$26; + __label__ = 9; break; + case 6: + __label__ = 7; break; + case 7: + var $29=$i; + var $30=((($29)+(1))|0); + $i=$30; + __label__ = 3; break; + case 8: + $1=0; + __label__ = 9; break; + case 9: + var $33=$1; + ; + return $33; + default: assert(0, "bad label: " + __label__); + } +} + + +function _prog_delete($prog) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + $1=$prog; + var $2=$1; + var $3=(($2)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $7=$1; + var $8=(($7)|0); + var $9=HEAP32[(($8)>>2)]; + _util_memory_d($9, 182, ((STRING_TABLE.__str)|0)); + __label__ = 4; break; + case 4: + var $11=$1; + var $12=(($11+4)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13)|0)!=0; + if ($14) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $16=$1; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$18; + _util_memory_d($19, 183, ((STRING_TABLE.__str)|0)); + __label__ = 6; break; + case 6: + var $21=$1; + var $22=(($21+4)|0); + HEAP32[(($22)>>2)]=0; + var $23=$1; + var $24=(($23+8)|0); + HEAP32[(($24)>>2)]=0; + var $25=$1; + var $26=(($25+12)|0); + HEAP32[(($26)>>2)]=0; + var $27=$1; + var $28=(($27+16)|0); + var $29=HEAP32[(($28)>>2)]; + var $30=(($29)|0)!=0; + if ($30) { __label__ = 7; break; } else { __label__ = 8; break; } + case 7: + var $32=$1; + var $33=(($32+16)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=$34; + _util_memory_d($35, 184, ((STRING_TABLE.__str)|0)); + __label__ = 8; break; + case 8: + var $37=$1; + var $38=(($37+16)|0); + HEAP32[(($38)>>2)]=0; + var $39=$1; + var $40=(($39+20)|0); + HEAP32[(($40)>>2)]=0; + var $41=$1; + var $42=(($41+24)|0); + HEAP32[(($42)>>2)]=0; + var $43=$1; + var $44=(($43+28)|0); + var $45=HEAP32[(($44)>>2)]; + var $46=(($45)|0)!=0; + if ($46) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + var $48=$1; + var $49=(($48+28)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=$50; + _util_memory_d($51, 185, ((STRING_TABLE.__str)|0)); + __label__ = 10; break; + case 10: + var $53=$1; + var $54=(($53+28)|0); + HEAP32[(($54)>>2)]=0; + var $55=$1; + var $56=(($55+32)|0); + HEAP32[(($56)>>2)]=0; + var $57=$1; + var $58=(($57+36)|0); + HEAP32[(($58)>>2)]=0; + var $59=$1; + var $60=(($59+40)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=(($61)|0)!=0; + if ($62) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $64=$1; + var $65=(($64+40)|0); + var $66=HEAP32[(($65)>>2)]; + var $67=$66; + _util_memory_d($67, 186, ((STRING_TABLE.__str)|0)); + __label__ = 12; break; + case 12: + var $69=$1; + var $70=(($69+40)|0); + HEAP32[(($70)>>2)]=0; + var $71=$1; + var $72=(($71+44)|0); + HEAP32[(($72)>>2)]=0; + var $73=$1; + var $74=(($73+48)|0); + HEAP32[(($74)>>2)]=0; + var $75=$1; + var $76=(($75+52)|0); + var $77=HEAP32[(($76)>>2)]; + var $78=(($77)|0)!=0; + if ($78) { __label__ = 13; break; } else { __label__ = 14; break; } + case 13: + var $80=$1; + var $81=(($80+52)|0); + var $82=HEAP32[(($81)>>2)]; + _util_memory_d($82, 187, ((STRING_TABLE.__str)|0)); + __label__ = 14; break; + case 14: + var $84=$1; + var $85=(($84+52)|0); + HEAP32[(($85)>>2)]=0; + var $86=$1; + var $87=(($86+56)|0); + HEAP32[(($87)>>2)]=0; + var $88=$1; + var $89=(($88+60)|0); + HEAP32[(($89)>>2)]=0; + var $90=$1; + var $91=(($90+64)|0); + var $92=HEAP32[(($91)>>2)]; + var $93=(($92)|0)!=0; + if ($93) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $95=$1; + var $96=(($95+64)|0); + var $97=HEAP32[(($96)>>2)]; + var $98=$97; + _util_memory_d($98, 188, ((STRING_TABLE.__str)|0)); + __label__ = 16; break; + case 16: + var $100=$1; + var $101=(($100+64)|0); + HEAP32[(($101)>>2)]=0; + var $102=$1; + var $103=(($102+68)|0); + HEAP32[(($103)>>2)]=0; + var $104=$1; + var $105=(($104+72)|0); + HEAP32[(($105)>>2)]=0; + var $106=$1; + var $107=(($106+76)|0); + var $108=HEAP32[(($107)>>2)]; + var $109=(($108)|0)!=0; + if ($109) { __label__ = 17; break; } else { __label__ = 18; break; } + case 17: + var $111=$1; + var $112=(($111+76)|0); + var $113=HEAP32[(($112)>>2)]; + var $114=$113; + _util_memory_d($114, 189, ((STRING_TABLE.__str)|0)); + __label__ = 18; break; + case 18: + var $116=$1; + var $117=(($116+76)|0); + HEAP32[(($117)>>2)]=0; + var $118=$1; + var $119=(($118+80)|0); + HEAP32[(($119)>>2)]=0; + var $120=$1; + var $121=(($120+84)|0); + HEAP32[(($121)>>2)]=0; + var $122=$1; + var $123=(($122+88)|0); + var $124=HEAP32[(($123)>>2)]; + var $125=(($124)|0)!=0; + if ($125) { __label__ = 19; break; } else { __label__ = 20; break; } + case 19: + var $127=$1; + var $128=(($127+88)|0); + var $129=HEAP32[(($128)>>2)]; + _util_memory_d($129, 190, ((STRING_TABLE.__str)|0)); + __label__ = 20; break; + case 20: + var $131=$1; + var $132=(($131+88)|0); + HEAP32[(($132)>>2)]=0; + var $133=$1; + var $134=(($133+92)|0); + HEAP32[(($134)>>2)]=0; + var $135=$1; + var $136=(($135+96)|0); + HEAP32[(($136)>>2)]=0; + var $137=$1; + var $138=(($137+152)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=(($139)|0)!=0; + if ($140) { __label__ = 21; break; } else { __label__ = 22; break; } + case 21: + var $142=$1; + var $143=(($142+152)|0); + var $144=HEAP32[(($143)>>2)]; + var $145=$144; + _util_memory_d($145, 191, ((STRING_TABLE.__str)|0)); + __label__ = 22; break; + case 22: + var $147=$1; + var $148=(($147+152)|0); + HEAP32[(($148)>>2)]=0; + var $149=$1; + var $150=(($149+156)|0); + HEAP32[(($150)>>2)]=0; + var $151=$1; + var $152=(($151+160)|0); + HEAP32[(($152)>>2)]=0; + var $153=$1; + var $154=(($153+164)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=(($155)|0)!=0; + if ($156) { __label__ = 23; break; } else { __label__ = 24; break; } + case 23: + var $158=$1; + var $159=(($158+164)|0); + var $160=HEAP32[(($159)>>2)]; + var $161=$160; + _util_memory_d($161, 192, ((STRING_TABLE.__str)|0)); + __label__ = 24; break; + case 24: + var $163=$1; + var $164=(($163+164)|0); + HEAP32[(($164)>>2)]=0; + var $165=$1; + var $166=(($165+168)|0); + HEAP32[(($166)>>2)]=0; + var $167=$1; + var $168=(($167+172)|0); + HEAP32[(($168)>>2)]=0; + var $169=$1; + var $170=(($169+116)|0); + var $171=HEAP32[(($170)>>2)]; + var $172=(($171)|0)!=0; + if ($172) { __label__ = 25; break; } else { __label__ = 26; break; } + case 25: + var $174=$1; + var $175=(($174+116)|0); + var $176=HEAP32[(($175)>>2)]; + var $177=$176; + _util_memory_d($177, 193, ((STRING_TABLE.__str)|0)); + __label__ = 26; break; + case 26: + var $179=$1; + var $180=(($179+116)|0); + HEAP32[(($180)>>2)]=0; + var $181=$1; + var $182=(($181+120)|0); + HEAP32[(($182)>>2)]=0; + var $183=$1; + var $184=(($183+124)|0); + HEAP32[(($184)>>2)]=0; + var $185=$1; + var $186=(($185+136)|0); + var $187=HEAP32[(($186)>>2)]; + var $188=(($187)|0)!=0; + if ($188) { __label__ = 27; break; } else { __label__ = 30; break; } + case 27: + var $190=$1; + var $191=(($190+128)|0); + var $192=HEAP32[(($191)>>2)]; + var $193=(($192)|0)!=0; + if ($193) { __label__ = 28; break; } else { __label__ = 29; break; } + case 28: + var $195=$1; + var $196=(($195+128)|0); + var $197=HEAP32[(($196)>>2)]; + var $198=$197; + _util_memory_d($198, 196, ((STRING_TABLE.__str)|0)); + __label__ = 29; break; + case 29: + var $200=$1; + var $201=(($200+128)|0); + HEAP32[(($201)>>2)]=0; + var $202=$1; + var $203=(($202+132)|0); + HEAP32[(($203)>>2)]=0; + var $204=$1; + var $205=(($204+136)|0); + HEAP32[(($205)>>2)]=0; + __label__ = 30; break; + case 30: + var $207=$1; + var $208=$207; + _util_memory_d($208, 199, ((STRING_TABLE.__str)|0)); + ; + return; + default: assert(0, "bad label: " + __label__); + } +} +_prog_delete["X"]=1; + +function _prog_getedict($prog, $e) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$prog; + $2=$e; + var $3=$2; + var $4=$1; + var $5=(($4+92)|0); + var $6=HEAP32[(($5)>>2)]; + var $7=(($3)>>>0) >= (($6)>>>0); + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$1; + var $10=(($9+112)|0); + var $11=HEAP32[(($10)>>2)]; + var $12=((($11)+(1))|0); + HEAP32[(($10)>>2)]=$12; + var $13=$2; + 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)); + $2=0; + __label__ = 4; break; + case 4: + var $16=$1; + var $17=(($16+76)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=$1; + var $20=(($19+144)|0); + var $21=HEAP32[(($20)>>2)]; + var $22=$2; + var $23=((($21)*($22))|0); + var $24=(($18+($23<<2))|0); + var $25=$24; + STACKTOP = __stackBase__; + return $25; + default: assert(0, "bad label: " + __label__); + } +} + + +function _prog_spawn_entity($prog) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $data; + var $i; + var $e; + $2=$prog; + $e=0; + __label__ = 3; break; + case 3: + var $4=$e; + var $5=$2; + var $6=(($5+92)|0); + var $7=HEAP32[(($6)>>2)]; + var $8=(($4)|0) < (($7)|0); + if ($8) { __label__ = 4; break; } else { __label__ = 8; break; } + case 4: + var $10=$e; + var $11=$2; + var $12=(($11+88)|0); + var $13=HEAP32[(($12)>>2)]; + var $14=(($13+$10)|0); + var $15=HEAP8[($14)]; + var $16=(($15) & 1); + if ($16) { __label__ = 6; break; } else { __label__ = 5; break; } + case 5: + var $18=$2; + var $19=(($18+76)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=$2; + var $22=(($21+144)|0); + var $23=HEAP32[(($22)>>2)]; + var $24=$e; + var $25=((($23)*($24))|0); + var $26=(($20+($25<<2))|0); + var $27=$26; + $data=$27; + var $28=$data; + var $29=$2; + var $30=(($29+144)|0); + var $31=HEAP32[(($30)>>2)]; + var $32=((($31<<2))|0); + _memset($28, 0, $32, 1); + var $33=$e; + $1=$33; + __label__ = 17; break; + case 6: + __label__ = 7; break; + case 7: + var $36=$e; + var $37=((($36)+(1))|0); + $e=$37; + __label__ = 3; break; + case 8: + var $39=$2; + var $40=_qc_program_entitypool_add($39, 1); + if ($40) { __label__ = 10; break; } else { __label__ = 9; break; } + case 9: + var $42=$2; + var $43=(($42+112)|0); + var $44=HEAP32[(($43)>>2)]; + var $45=((($44)+(1))|0); + HEAP32[(($43)>>2)]=$45; + 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)); + $1=0; + __label__ = 17; break; + case 10: + var $48=$2; + var $49=(($48+140)|0); + var $50=HEAP32[(($49)>>2)]; + var $51=((($50)+(1))|0); + HEAP32[(($49)>>2)]=$51; + $i=0; + __label__ = 11; break; + case 11: + var $53=$i; + var $54=$2; + var $55=(($54+144)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($53)>>>0) < (($56)>>>0); + if ($57) { __label__ = 12; break; } else { __label__ = 16; break; } + case 12: + var $59=$2; + var $60=_qc_program_entitydata_add($59, 0); + if ($60) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + 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)); + $1=0; + __label__ = 17; break; + case 14: + __label__ = 15; break; + case 15: + var $65=$i; + var $66=((($65)+(1))|0); + $i=$66; + __label__ = 11; break; + case 16: + var $68=$2; + var $69=(($68+76)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=$2; + var $72=(($71+144)|0); + var $73=HEAP32[(($72)>>2)]; + var $74=$e; + var $75=((($73)*($74))|0); + var $76=(($70+($75<<2))|0); + var $77=$76; + $data=$77; + var $78=$data; + var $79=$2; + var $80=(($79+144)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=((($81<<2))|0); + _memset($78, 0, $82, 1); + var $83=$e; + $1=$83; + __label__ = 17; break; + case 17: + var $85=$1; + STACKTOP = __stackBase__; + return $85; + default: assert(0, "bad label: " + __label__); + } +} +_prog_spawn_entity["X"]=1; + +function _prog_free_entity($prog, $e) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + $1=$prog; + $2=$e; + var $3=$2; + var $4=(($3)|0)!=0; + if ($4) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + var $6=$1; + var $7=(($6+112)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=((($8)+(1))|0); + HEAP32[(($7)>>2)]=$9; + 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)); + __label__ = 9; break; + case 4: + var $12=$2; + var $13=$1; + var $14=(($13+92)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)>>>0) >= (($15)>>>0); + if ($16) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $18=$1; + var $19=(($18+112)|0); + var $20=HEAP32[(($19)>>2)]; + var $21=((($20)+(1))|0); + HEAP32[(($19)>>2)]=$21; + 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)); + __label__ = 9; break; + case 6: + var $24=$2; + var $25=$1; + var $26=(($25+88)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($27+$24)|0); + var $29=HEAP8[($28)]; + var $30=(($29) & 1); + if ($30) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + var $32=$1; + var $33=(($32+112)|0); + var $34=HEAP32[(($33)>>2)]; + var $35=((($34)+(1))|0); + HEAP32[(($33)>>2)]=$35; + 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)); + __label__ = 9; break; + case 8: + var $38=$2; + var $39=$1; + var $40=(($39+88)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=(($41+$38)|0); + HEAP8[($42)]=0; + __label__ = 9; break; + case 9: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_prog_free_entity["X"]=1; + +function _prog_tempstring($prog, $_str) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $str; + var $len; + var $at; + $2=$prog; + $3=$_str; + var $4=$3; + $str=$4; + var $5=$str; + var $6=_strlen($5); + $len=$6; + var $7=$2; + var $8=(($7+108)|0); + var $9=HEAP32[(($8)>>2)]; + $at=$9; + var $10=$at; + var $11=$len; + var $12=((($10)+($11))|0); + var $13=$2; + var $14=(($13+56)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($12)>>>0) >= (($15)>>>0); + if ($16) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $18=$2; + var $19=(($18+104)|0); + var $20=HEAP32[(($19)>>2)]; + $at=$20; + __label__ = 4; break; + case 4: + var $22=$at; + var $23=$len; + var $24=((($22)+($23))|0); + var $25=$2; + var $26=(($25+56)|0); + var $27=HEAP32[(($26)>>2)]; + var $28=(($24)>>>0) >= (($27)>>>0); + if ($28) { __label__ = 5; break; } else { __label__ = 8; break; } + case 5: + var $30=$at; + var $31=$2; + var $32=(($31+56)|0); + HEAP32[(($32)>>2)]=$30; + var $33=$2; + var $34=$str; + var $35=$len; + var $36=((($35)+(1))|0); + var $37=_qc_program_strings_append($33, $34, $36); + if ($37) { __label__ = 7; break; } else { __label__ = 6; break; } + case 6: + var $39=$2; + var $40=(($39+112)|0); + HEAP32[(($40)>>2)]=1; + $1=0; + __label__ = 9; break; + case 7: + var $42=$at; + $1=$42; + __label__ = 9; break; + case 8: + var $44=$2; + var $45=(($44+52)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$at; + var $48=(($46+$47)|0); + var $49=$str; + var $50=$len; + var $51=((($50)+(1))|0); + assert($51 % 1 === 0, 'memcpy given ' + $51 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($48, $49, $51, 1); + var $52=$len; + var $53=((($52)+(1))|0); + var $54=$2; + var $55=(($54+108)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=((($56)+($53))|0); + HEAP32[(($55)>>2)]=$57; + var $58=$at; + $1=$58; + __label__ = 9; break; + case 9: + var $60=$1; + ; + return $60; + default: assert(0, "bad label: " + __label__); + } +} +_prog_tempstring["X"]=1; + +function _prog_exec($prog, $func, $flags, $maxjumps) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $4; + var $5; + var $jumpcount; + var $oldxflags; + var $st; + var $newf; + var $ed; + var $ptr; + var $builtinnumber; + var $newf1; + var $ed2; + var $ptr3; + var $builtinnumber4; + var $newf5; + var $ed6; + var $ptr7; + var $builtinnumber8; + var $newf9; + var $ed10; + var $ptr11; + var $builtinnumber12; + $2=$prog; + $3=$func; + $4=$flags; + $5=$maxjumps; + $jumpcount=0; + var $6=$2; + var $7=(($6+180)|0); + var $8=HEAP32[(($7)>>2)]; + $oldxflags=$8; + var $9=$2; + var $10=(($9+112)|0); + HEAP32[(($10)>>2)]=0; + var $11=$4; + var $12=$2; + var $13=(($12+180)|0); + HEAP32[(($13)>>2)]=$11; + var $14=$2; + var $15=(($14+4)|0); + var $16=HEAP32[(($15)>>2)]; + var $17=$2; + var $18=$3; + var $19=_prog_enterfunction($17, $18); + var $20=(($16+($19<<3))|0); + $st=$20; + var $21=$st; + var $22=((($21)-(8))|0); + $st=$22; + var $23=$4; + if ((($23)|0) == 0) { + __label__ = 4; break; + } + else if ((($23)|0) == 1) { + __label__ = 125; break; + } + else if ((($23)|0) == 2) { + __label__ = 246; break; + } + else if ((($23)|0) == 3) { + __label__ = 367; break; + } + else { + __label__ = 3; break; + } + + case 3: + __label__ = 4; break; + case 4: + __label__ = 5; break; + case 5: + var $27=$st; + var $28=(($27+8)|0); + $st=$28; + var $29=$st; + var $30=(($29)|0); + var $31=HEAP16[(($30)>>1)]; + var $32=(($31)&65535); + if ((($32)|0) == 0 || (($32)|0) == 43) { + __label__ = 7; break; + } + else if ((($32)|0) == 1) { + __label__ = 10; break; + } + else if ((($32)|0) == 2) { + __label__ = 11; break; + } + else if ((($32)|0) == 3) { + __label__ = 12; break; + } + else if ((($32)|0) == 4) { + __label__ = 13; break; + } + else if ((($32)|0) == 5) { + __label__ = 14; break; + } + else if ((($32)|0) == 6) { + __label__ = 18; break; + } + else if ((($32)|0) == 7) { + __label__ = 19; break; + } + else if ((($32)|0) == 8) { + __label__ = 20; break; + } + else if ((($32)|0) == 9) { + __label__ = 21; break; + } + else if ((($32)|0) == 10) { + __label__ = 22; break; + } + else if ((($32)|0) == 11) { + __label__ = 23; break; + } + else if ((($32)|0) == 12) { + __label__ = 27; break; + } + else if ((($32)|0) == 13) { + __label__ = 28; break; + } + else if ((($32)|0) == 14) { + __label__ = 29; break; + } + else if ((($32)|0) == 15) { + __label__ = 30; break; + } + else if ((($32)|0) == 16) { + __label__ = 31; break; + } + else if ((($32)|0) == 17) { + __label__ = 35; break; + } + else if ((($32)|0) == 18) { + __label__ = 36; break; + } + else if ((($32)|0) == 19) { + __label__ = 37; break; + } + else if ((($32)|0) == 20) { + __label__ = 38; break; + } + else if ((($32)|0) == 21) { + __label__ = 39; break; + } + else if ((($32)|0) == 22) { + __label__ = 40; break; + } + else if ((($32)|0) == 23) { + __label__ = 41; break; + } + else if ((($32)|0) == 24 || (($32)|0) == 26 || (($32)|0) == 28 || (($32)|0) == 27 || (($32)|0) == 29) { + __label__ = 42; break; + } + else if ((($32)|0) == 25) { + __label__ = 48; break; + } + else if ((($32)|0) == 30) { + __label__ = 55; break; + } + else if ((($32)|0) == 31 || (($32)|0) == 33 || (($32)|0) == 34 || (($32)|0) == 35 || (($32)|0) == 36) { + __label__ = 61; break; + } + else if ((($32)|0) == 32) { + __label__ = 62; break; + } + else if ((($32)|0) == 37 || (($32)|0) == 39 || (($32)|0) == 40 || (($32)|0) == 41 || (($32)|0) == 42) { + __label__ = 63; break; + } + else if ((($32)|0) == 38) { + __label__ = 70; break; + } + else if ((($32)|0) == 44) { + __label__ = 77; break; + } + else if ((($32)|0) == 45) { + __label__ = 78; break; + } + else if ((($32)|0) == 46) { + __label__ = 82; break; + } + else if ((($32)|0) == 47) { + __label__ = 85; break; + } + else if ((($32)|0) == 48) { + __label__ = 86; break; + } + else if ((($32)|0) == 49) { + __label__ = 87; break; + } + else if ((($32)|0) == 50) { + __label__ = 92; break; + } + 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) { + __label__ = 97; break; + } + else if ((($32)|0) == 60) { + __label__ = 112; break; + } + else if ((($32)|0) == 61) { + __label__ = 113; break; + } + else if ((($32)|0) == 62) { + __label__ = 116; break; + } + else if ((($32)|0) == 63) { + __label__ = 119; break; + } + else if ((($32)|0) == 64) { + __label__ = 122; break; + } + else if ((($32)|0) == 65) { + __label__ = 123; break; + } + else { + __label__ = 6; break; + } + + case 6: + var $34=$2; + var $35=$2; + var $36=(($35)|0); + var $37=HEAP32[(($36)>>2)]; + _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)); + __label__ = 488; break; + case 7: + var $39=$2; + var $40=(($39+64)|0); + var $41=HEAP32[(($40)>>2)]; + var $42=$st; + var $43=(($42+2)|0); + var $44=$43; + var $45=HEAP16[(($44)>>1)]; + var $46=(($45)&65535); + var $47=(($41+($46<<2))|0); + var $48=$47; + var $49=$48; + var $50=(($49)|0); + var $51=HEAP32[(($50)>>2)]; + var $52=$2; + var $53=(($52+64)|0); + var $54=HEAP32[(($53)>>2)]; + var $55=(($54+4)|0); + var $56=$55; + var $57=$56; + var $58=(($57)|0); + HEAP32[(($58)>>2)]=$51; + var $59=$2; + var $60=(($59+64)|0); + var $61=HEAP32[(($60)>>2)]; + var $62=$st; + var $63=(($62+2)|0); + var $64=$63; + var $65=HEAP16[(($64)>>1)]; + var $66=(($65)&65535); + var $67=(($61+($66<<2))|0); + var $68=$67; + var $69=$68; + var $70=(($69+4)|0); + var $71=HEAP32[(($70)>>2)]; + var $72=$2; + var $73=(($72+64)|0); + var $74=HEAP32[(($73)>>2)]; + var $75=(($74+4)|0); + var $76=$75; + var $77=$76; + var $78=(($77+4)|0); + HEAP32[(($78)>>2)]=$71; + var $79=$2; + var $80=(($79+64)|0); + var $81=HEAP32[(($80)>>2)]; + var $82=$st; + var $83=(($82+2)|0); + var $84=$83; + var $85=HEAP16[(($84)>>1)]; + var $86=(($85)&65535); + var $87=(($81+($86<<2))|0); + var $88=$87; + var $89=$88; + var $90=(($89+8)|0); + var $91=HEAP32[(($90)>>2)]; + var $92=$2; + var $93=(($92+64)|0); + var $94=HEAP32[(($93)>>2)]; + var $95=(($94+4)|0); + var $96=$95; + var $97=$96; + var $98=(($97+8)|0); + HEAP32[(($98)>>2)]=$91; + var $99=$2; + var $100=(($99+4)|0); + var $101=HEAP32[(($100)>>2)]; + var $102=$2; + var $103=_prog_leavefunction($102); + var $104=(($101+($103<<3))|0); + $st=$104; + var $105=$2; + var $106=(($105+168)|0); + var $107=HEAP32[(($106)>>2)]; + var $108=(($107)|0)!=0; + if ($108) { __label__ = 9; break; } else { __label__ = 8; break; } + case 8: + __label__ = 488; break; + case 9: + __label__ = 124; break; + case 10: + var $112=$2; + var $113=(($112+64)|0); + var $114=HEAP32[(($113)>>2)]; + var $115=$st; + var $116=(($115+2)|0); + var $117=$116; + var $118=HEAP16[(($117)>>1)]; + var $119=(($118)&65535); + var $120=(($114+($119<<2))|0); + var $121=$120; + var $122=$121; + var $123=HEAPF32[(($122)>>2)]; + var $124=$2; + var $125=(($124+64)|0); + var $126=HEAP32[(($125)>>2)]; + var $127=$st; + var $128=(($127+4)|0); + var $129=$128; + var $130=HEAP16[(($129)>>1)]; + var $131=(($130)&65535); + var $132=(($126+($131<<2))|0); + var $133=$132; + var $134=$133; + var $135=HEAPF32[(($134)>>2)]; + var $136=($123)*($135); + var $137=$2; + var $138=(($137+64)|0); + var $139=HEAP32[(($138)>>2)]; + var $140=$st; + var $141=(($140+6)|0); + var $142=$141; + var $143=HEAP16[(($142)>>1)]; + var $144=(($143)&65535); + var $145=(($139+($144<<2))|0); + var $146=$145; + var $147=$146; + HEAPF32[(($147)>>2)]=$136; + __label__ = 124; break; + case 11: + var $149=$2; + var $150=(($149+64)|0); + var $151=HEAP32[(($150)>>2)]; + var $152=$st; + var $153=(($152+2)|0); + var $154=$153; + var $155=HEAP16[(($154)>>1)]; + var $156=(($155)&65535); + var $157=(($151+($156<<2))|0); + var $158=$157; + var $159=$158; + var $160=(($159)|0); + var $161=HEAPF32[(($160)>>2)]; + var $162=$2; + var $163=(($162+64)|0); + var $164=HEAP32[(($163)>>2)]; + var $165=$st; + var $166=(($165+4)|0); + var $167=$166; + var $168=HEAP16[(($167)>>1)]; + var $169=(($168)&65535); + var $170=(($164+($169<<2))|0); + var $171=$170; + var $172=$171; + var $173=(($172)|0); + var $174=HEAPF32[(($173)>>2)]; + var $175=($161)*($174); + var $176=$2; + var $177=(($176+64)|0); + var $178=HEAP32[(($177)>>2)]; + var $179=$st; + var $180=(($179+2)|0); + var $181=$180; + var $182=HEAP16[(($181)>>1)]; + var $183=(($182)&65535); + var $184=(($178+($183<<2))|0); + var $185=$184; + var $186=$185; + var $187=(($186+4)|0); + var $188=HEAPF32[(($187)>>2)]; + var $189=$2; + var $190=(($189+64)|0); + var $191=HEAP32[(($190)>>2)]; + var $192=$st; + var $193=(($192+4)|0); + var $194=$193; + var $195=HEAP16[(($194)>>1)]; + var $196=(($195)&65535); + var $197=(($191+($196<<2))|0); + var $198=$197; + var $199=$198; + var $200=(($199+4)|0); + var $201=HEAPF32[(($200)>>2)]; + var $202=($188)*($201); + var $203=($175)+($202); + var $204=$2; + var $205=(($204+64)|0); + var $206=HEAP32[(($205)>>2)]; + var $207=$st; + var $208=(($207+2)|0); + var $209=$208; + var $210=HEAP16[(($209)>>1)]; + var $211=(($210)&65535); + var $212=(($206+($211<<2))|0); + var $213=$212; + var $214=$213; + var $215=(($214+8)|0); + var $216=HEAPF32[(($215)>>2)]; + var $217=$2; + var $218=(($217+64)|0); + var $219=HEAP32[(($218)>>2)]; + var $220=$st; + var $221=(($220+4)|0); + var $222=$221; + var $223=HEAP16[(($222)>>1)]; + var $224=(($223)&65535); + var $225=(($219+($224<<2))|0); + var $226=$225; + var $227=$226; + var $228=(($227+8)|0); + var $229=HEAPF32[(($228)>>2)]; + var $230=($216)*($229); + var $231=($203)+($230); + var $232=$2; + var $233=(($232+64)|0); + var $234=HEAP32[(($233)>>2)]; + var $235=$st; + var $236=(($235+6)|0); + var $237=$236; + var $238=HEAP16[(($237)>>1)]; + var $239=(($238)&65535); + var $240=(($234+($239<<2))|0); + var $241=$240; + var $242=$241; + HEAPF32[(($242)>>2)]=$231; + __label__ = 124; break; + case 12: + var $244=$2; + var $245=(($244+64)|0); + var $246=HEAP32[(($245)>>2)]; + var $247=$st; + var $248=(($247+2)|0); + var $249=$248; + var $250=HEAP16[(($249)>>1)]; + var $251=(($250)&65535); + var $252=(($246+($251<<2))|0); + var $253=$252; + var $254=$253; + var $255=HEAPF32[(($254)>>2)]; + var $256=$2; + var $257=(($256+64)|0); + var $258=HEAP32[(($257)>>2)]; + var $259=$st; + var $260=(($259+4)|0); + var $261=$260; + var $262=HEAP16[(($261)>>1)]; + var $263=(($262)&65535); + var $264=(($258+($263<<2))|0); + var $265=$264; + var $266=$265; + var $267=(($266)|0); + var $268=HEAPF32[(($267)>>2)]; + var $269=($255)*($268); + var $270=$2; + var $271=(($270+64)|0); + var $272=HEAP32[(($271)>>2)]; + var $273=$st; + var $274=(($273+6)|0); + var $275=$274; + var $276=HEAP16[(($275)>>1)]; + var $277=(($276)&65535); + var $278=(($272+($277<<2))|0); + var $279=$278; + var $280=$279; + var $281=(($280)|0); + HEAPF32[(($281)>>2)]=$269; + var $282=$2; + var $283=(($282+64)|0); + var $284=HEAP32[(($283)>>2)]; + var $285=$st; + var $286=(($285+2)|0); + var $287=$286; + var $288=HEAP16[(($287)>>1)]; + var $289=(($288)&65535); + var $290=(($284+($289<<2))|0); + var $291=$290; + var $292=$291; + var $293=HEAPF32[(($292)>>2)]; + var $294=$2; + var $295=(($294+64)|0); + var $296=HEAP32[(($295)>>2)]; + var $297=$st; + var $298=(($297+4)|0); + var $299=$298; + var $300=HEAP16[(($299)>>1)]; + var $301=(($300)&65535); + var $302=(($296+($301<<2))|0); + var $303=$302; + var $304=$303; + var $305=(($304+4)|0); + var $306=HEAPF32[(($305)>>2)]; + var $307=($293)*($306); + var $308=$2; + var $309=(($308+64)|0); + var $310=HEAP32[(($309)>>2)]; + var $311=$st; + var $312=(($311+6)|0); + var $313=$312; + var $314=HEAP16[(($313)>>1)]; + var $315=(($314)&65535); + var $316=(($310+($315<<2))|0); + var $317=$316; + var $318=$317; + var $319=(($318+4)|0); + HEAPF32[(($319)>>2)]=$307; + var $320=$2; + var $321=(($320+64)|0); + var $322=HEAP32[(($321)>>2)]; + var $323=$st; + var $324=(($323+2)|0); + var $325=$324; + var $326=HEAP16[(($325)>>1)]; + var $327=(($326)&65535); + var $328=(($322+($327<<2))|0); + var $329=$328; + var $330=$329; + var $331=HEAPF32[(($330)>>2)]; + var $332=$2; + var $333=(($332+64)|0); + var $334=HEAP32[(($333)>>2)]; + var $335=$st; + var $336=(($335+4)|0); + var $337=$336; + var $338=HEAP16[(($337)>>1)]; + var $339=(($338)&65535); + var $340=(($334+($339<<2))|0); + var $341=$340; + var $342=$341; + var $343=(($342+8)|0); + var $344=HEAPF32[(($343)>>2)]; + var $345=($331)*($344); + var $346=$2; + var $347=(($346+64)|0); + var $348=HEAP32[(($347)>>2)]; + var $349=$st; + var $350=(($349+6)|0); + var $351=$350; + var $352=HEAP16[(($351)>>1)]; + var $353=(($352)&65535); + var $354=(($348+($353<<2))|0); + var $355=$354; + var $356=$355; + var $357=(($356+8)|0); + HEAPF32[(($357)>>2)]=$345; + __label__ = 124; break; + case 13: + var $359=$2; + var $360=(($359+64)|0); + var $361=HEAP32[(($360)>>2)]; + var $362=$st; + var $363=(($362+4)|0); + var $364=$363; + var $365=HEAP16[(($364)>>1)]; + var $366=(($365)&65535); + var $367=(($361+($366<<2))|0); + var $368=$367; + var $369=$368; + var $370=HEAPF32[(($369)>>2)]; + var $371=$2; + var $372=(($371+64)|0); + var $373=HEAP32[(($372)>>2)]; + var $374=$st; + var $375=(($374+2)|0); + var $376=$375; + var $377=HEAP16[(($376)>>1)]; + var $378=(($377)&65535); + var $379=(($373+($378<<2))|0); + var $380=$379; + var $381=$380; + var $382=(($381)|0); + var $383=HEAPF32[(($382)>>2)]; + var $384=($370)*($383); + var $385=$2; + var $386=(($385+64)|0); + var $387=HEAP32[(($386)>>2)]; + var $388=$st; + var $389=(($388+6)|0); + var $390=$389; + var $391=HEAP16[(($390)>>1)]; + var $392=(($391)&65535); + var $393=(($387+($392<<2))|0); + var $394=$393; + var $395=$394; + var $396=(($395)|0); + HEAPF32[(($396)>>2)]=$384; + var $397=$2; + var $398=(($397+64)|0); + var $399=HEAP32[(($398)>>2)]; + var $400=$st; + var $401=(($400+4)|0); + var $402=$401; + var $403=HEAP16[(($402)>>1)]; + var $404=(($403)&65535); + var $405=(($399+($404<<2))|0); + var $406=$405; + var $407=$406; + var $408=HEAPF32[(($407)>>2)]; + var $409=$2; + var $410=(($409+64)|0); + var $411=HEAP32[(($410)>>2)]; + var $412=$st; + var $413=(($412+2)|0); + var $414=$413; + var $415=HEAP16[(($414)>>1)]; + var $416=(($415)&65535); + var $417=(($411+($416<<2))|0); + var $418=$417; + var $419=$418; + var $420=(($419+4)|0); + var $421=HEAPF32[(($420)>>2)]; + var $422=($408)*($421); + var $423=$2; + var $424=(($423+64)|0); + var $425=HEAP32[(($424)>>2)]; + var $426=$st; + var $427=(($426+6)|0); + var $428=$427; + var $429=HEAP16[(($428)>>1)]; + var $430=(($429)&65535); + var $431=(($425+($430<<2))|0); + var $432=$431; + var $433=$432; + var $434=(($433+4)|0); + HEAPF32[(($434)>>2)]=$422; + var $435=$2; + var $436=(($435+64)|0); + var $437=HEAP32[(($436)>>2)]; + var $438=$st; + var $439=(($438+4)|0); + var $440=$439; + var $441=HEAP16[(($440)>>1)]; + var $442=(($441)&65535); + var $443=(($437+($442<<2))|0); + var $444=$443; + var $445=$444; + var $446=HEAPF32[(($445)>>2)]; + var $447=$2; + var $448=(($447+64)|0); + var $449=HEAP32[(($448)>>2)]; + var $450=$st; + var $451=(($450+2)|0); + var $452=$451; + var $453=HEAP16[(($452)>>1)]; + var $454=(($453)&65535); + var $455=(($449+($454<<2))|0); + var $456=$455; + var $457=$456; + var $458=(($457+8)|0); + var $459=HEAPF32[(($458)>>2)]; + var $460=($446)*($459); + var $461=$2; + var $462=(($461+64)|0); + var $463=HEAP32[(($462)>>2)]; + var $464=$st; + var $465=(($464+6)|0); + var $466=$465; + var $467=HEAP16[(($466)>>1)]; + var $468=(($467)&65535); + var $469=(($463+($468<<2))|0); + var $470=$469; + var $471=$470; + var $472=(($471+8)|0); + HEAPF32[(($472)>>2)]=$460; + __label__ = 124; break; + case 14: + var $474=$2; + var $475=(($474+64)|0); + var $476=HEAP32[(($475)>>2)]; + var $477=$st; + var $478=(($477+4)|0); + var $479=$478; + var $480=HEAP16[(($479)>>1)]; + var $481=(($480)&65535); + var $482=(($476+($481<<2))|0); + var $483=$482; + var $484=$483; + var $485=HEAPF32[(($484)>>2)]; + var $486=$485 != 0; + if ($486) { __label__ = 15; break; } else { __label__ = 16; break; } + case 15: + var $488=$2; + var $489=(($488+64)|0); + var $490=HEAP32[(($489)>>2)]; + var $491=$st; + var $492=(($491+2)|0); + var $493=$492; + var $494=HEAP16[(($493)>>1)]; + var $495=(($494)&65535); + var $496=(($490+($495<<2))|0); + var $497=$496; + var $498=$497; + var $499=HEAPF32[(($498)>>2)]; + var $500=$2; + var $501=(($500+64)|0); + var $502=HEAP32[(($501)>>2)]; + var $503=$st; + var $504=(($503+4)|0); + var $505=$504; + var $506=HEAP16[(($505)>>1)]; + var $507=(($506)&65535); + var $508=(($502+($507<<2))|0); + var $509=$508; + var $510=$509; + var $511=HEAPF32[(($510)>>2)]; + var $512=($499)/($511); + var $513=$2; + var $514=(($513+64)|0); + var $515=HEAP32[(($514)>>2)]; + var $516=$st; + var $517=(($516+6)|0); + var $518=$517; + var $519=HEAP16[(($518)>>1)]; + var $520=(($519)&65535); + var $521=(($515+($520<<2))|0); + var $522=$521; + var $523=$522; + HEAPF32[(($523)>>2)]=$512; + __label__ = 17; break; + case 16: + var $525=$2; + var $526=(($525+64)|0); + var $527=HEAP32[(($526)>>2)]; + var $528=$st; + var $529=(($528+6)|0); + var $530=$529; + var $531=HEAP16[(($530)>>1)]; + var $532=(($531)&65535); + var $533=(($527+($532<<2))|0); + var $534=$533; + var $535=$534; + HEAPF32[(($535)>>2)]=0; + __label__ = 17; break; + case 17: + __label__ = 124; break; + case 18: + var $538=$2; + var $539=(($538+64)|0); + var $540=HEAP32[(($539)>>2)]; + var $541=$st; + var $542=(($541+2)|0); + var $543=$542; + var $544=HEAP16[(($543)>>1)]; + var $545=(($544)&65535); + var $546=(($540+($545<<2))|0); + var $547=$546; + var $548=$547; + var $549=HEAPF32[(($548)>>2)]; + var $550=$2; + var $551=(($550+64)|0); + var $552=HEAP32[(($551)>>2)]; + var $553=$st; + var $554=(($553+4)|0); + var $555=$554; + var $556=HEAP16[(($555)>>1)]; + var $557=(($556)&65535); + var $558=(($552+($557<<2))|0); + var $559=$558; + var $560=$559; + var $561=HEAPF32[(($560)>>2)]; + var $562=($549)+($561); + var $563=$2; + var $564=(($563+64)|0); + var $565=HEAP32[(($564)>>2)]; + var $566=$st; + var $567=(($566+6)|0); + var $568=$567; + var $569=HEAP16[(($568)>>1)]; + var $570=(($569)&65535); + var $571=(($565+($570<<2))|0); + var $572=$571; + var $573=$572; + HEAPF32[(($573)>>2)]=$562; + __label__ = 124; break; + case 19: + var $575=$2; + var $576=(($575+64)|0); + var $577=HEAP32[(($576)>>2)]; + var $578=$st; + var $579=(($578+2)|0); + var $580=$579; + var $581=HEAP16[(($580)>>1)]; + var $582=(($581)&65535); + var $583=(($577+($582<<2))|0); + var $584=$583; + var $585=$584; + var $586=(($585)|0); + var $587=HEAPF32[(($586)>>2)]; + var $588=$2; + var $589=(($588+64)|0); + var $590=HEAP32[(($589)>>2)]; + var $591=$st; + var $592=(($591+4)|0); + var $593=$592; + var $594=HEAP16[(($593)>>1)]; + var $595=(($594)&65535); + var $596=(($590+($595<<2))|0); + var $597=$596; + var $598=$597; + var $599=(($598)|0); + var $600=HEAPF32[(($599)>>2)]; + var $601=($587)+($600); + var $602=$2; + var $603=(($602+64)|0); + var $604=HEAP32[(($603)>>2)]; + var $605=$st; + var $606=(($605+6)|0); + var $607=$606; + var $608=HEAP16[(($607)>>1)]; + var $609=(($608)&65535); + var $610=(($604+($609<<2))|0); + var $611=$610; + var $612=$611; + var $613=(($612)|0); + HEAPF32[(($613)>>2)]=$601; + var $614=$2; + var $615=(($614+64)|0); + var $616=HEAP32[(($615)>>2)]; + var $617=$st; + var $618=(($617+2)|0); + var $619=$618; + var $620=HEAP16[(($619)>>1)]; + var $621=(($620)&65535); + var $622=(($616+($621<<2))|0); + var $623=$622; + var $624=$623; + var $625=(($624+4)|0); + var $626=HEAPF32[(($625)>>2)]; + var $627=$2; + var $628=(($627+64)|0); + var $629=HEAP32[(($628)>>2)]; + var $630=$st; + var $631=(($630+4)|0); + var $632=$631; + var $633=HEAP16[(($632)>>1)]; + var $634=(($633)&65535); + var $635=(($629+($634<<2))|0); + var $636=$635; + var $637=$636; + var $638=(($637+4)|0); + var $639=HEAPF32[(($638)>>2)]; + var $640=($626)+($639); + var $641=$2; + var $642=(($641+64)|0); + var $643=HEAP32[(($642)>>2)]; + var $644=$st; + var $645=(($644+6)|0); + var $646=$645; + var $647=HEAP16[(($646)>>1)]; + var $648=(($647)&65535); + var $649=(($643+($648<<2))|0); + var $650=$649; + var $651=$650; + var $652=(($651+4)|0); + HEAPF32[(($652)>>2)]=$640; + var $653=$2; + var $654=(($653+64)|0); + var $655=HEAP32[(($654)>>2)]; + var $656=$st; + var $657=(($656+2)|0); + var $658=$657; + var $659=HEAP16[(($658)>>1)]; + var $660=(($659)&65535); + var $661=(($655+($660<<2))|0); + var $662=$661; + var $663=$662; + var $664=(($663+8)|0); + var $665=HEAPF32[(($664)>>2)]; + var $666=$2; + var $667=(($666+64)|0); + var $668=HEAP32[(($667)>>2)]; + var $669=$st; + var $670=(($669+4)|0); + var $671=$670; + var $672=HEAP16[(($671)>>1)]; + var $673=(($672)&65535); + var $674=(($668+($673<<2))|0); + var $675=$674; + var $676=$675; + var $677=(($676+8)|0); + var $678=HEAPF32[(($677)>>2)]; + var $679=($665)+($678); + var $680=$2; + var $681=(($680+64)|0); + var $682=HEAP32[(($681)>>2)]; + var $683=$st; + var $684=(($683+6)|0); + var $685=$684; + var $686=HEAP16[(($685)>>1)]; + var $687=(($686)&65535); + var $688=(($682+($687<<2))|0); + var $689=$688; + var $690=$689; + var $691=(($690+8)|0); + HEAPF32[(($691)>>2)]=$679; + __label__ = 124; break; + case 20: + var $693=$2; + var $694=(($693+64)|0); + var $695=HEAP32[(($694)>>2)]; + var $696=$st; + var $697=(($696+2)|0); + var $698=$697; + var $699=HEAP16[(($698)>>1)]; + var $700=(($699)&65535); + var $701=(($695+($700<<2))|0); + var $702=$701; + var $703=$702; + var $704=HEAPF32[(($703)>>2)]; + var $705=$2; + var $706=(($705+64)|0); + var $707=HEAP32[(($706)>>2)]; + var $708=$st; + var $709=(($708+4)|0); + var $710=$709; + var $711=HEAP16[(($710)>>1)]; + var $712=(($711)&65535); + var $713=(($707+($712<<2))|0); + var $714=$713; + var $715=$714; + var $716=HEAPF32[(($715)>>2)]; + var $717=($704)-($716); + var $718=$2; + var $719=(($718+64)|0); + var $720=HEAP32[(($719)>>2)]; + var $721=$st; + var $722=(($721+6)|0); + var $723=$722; + var $724=HEAP16[(($723)>>1)]; + var $725=(($724)&65535); + var $726=(($720+($725<<2))|0); + var $727=$726; + var $728=$727; + HEAPF32[(($728)>>2)]=$717; + __label__ = 124; break; + case 21: + var $730=$2; + var $731=(($730+64)|0); + var $732=HEAP32[(($731)>>2)]; + var $733=$st; + var $734=(($733+2)|0); + var $735=$734; + var $736=HEAP16[(($735)>>1)]; + var $737=(($736)&65535); + var $738=(($732+($737<<2))|0); + var $739=$738; + var $740=$739; + var $741=(($740)|0); + var $742=HEAPF32[(($741)>>2)]; + var $743=$2; + var $744=(($743+64)|0); + var $745=HEAP32[(($744)>>2)]; + var $746=$st; + var $747=(($746+4)|0); + var $748=$747; + var $749=HEAP16[(($748)>>1)]; + var $750=(($749)&65535); + var $751=(($745+($750<<2))|0); + var $752=$751; + var $753=$752; + var $754=(($753)|0); + var $755=HEAPF32[(($754)>>2)]; + var $756=($742)-($755); + var $757=$2; + var $758=(($757+64)|0); + var $759=HEAP32[(($758)>>2)]; + var $760=$st; + var $761=(($760+6)|0); + var $762=$761; + var $763=HEAP16[(($762)>>1)]; + var $764=(($763)&65535); + var $765=(($759+($764<<2))|0); + var $766=$765; + var $767=$766; + var $768=(($767)|0); + HEAPF32[(($768)>>2)]=$756; + var $769=$2; + var $770=(($769+64)|0); + var $771=HEAP32[(($770)>>2)]; + var $772=$st; + var $773=(($772+2)|0); + var $774=$773; + var $775=HEAP16[(($774)>>1)]; + var $776=(($775)&65535); + var $777=(($771+($776<<2))|0); + var $778=$777; + var $779=$778; + var $780=(($779+4)|0); + var $781=HEAPF32[(($780)>>2)]; + var $782=$2; + var $783=(($782+64)|0); + var $784=HEAP32[(($783)>>2)]; + var $785=$st; + var $786=(($785+4)|0); + var $787=$786; + var $788=HEAP16[(($787)>>1)]; + var $789=(($788)&65535); + var $790=(($784+($789<<2))|0); + var $791=$790; + var $792=$791; + var $793=(($792+4)|0); + var $794=HEAPF32[(($793)>>2)]; + var $795=($781)-($794); + var $796=$2; + var $797=(($796+64)|0); + var $798=HEAP32[(($797)>>2)]; + var $799=$st; + var $800=(($799+6)|0); + var $801=$800; + var $802=HEAP16[(($801)>>1)]; + var $803=(($802)&65535); + var $804=(($798+($803<<2))|0); + var $805=$804; + var $806=$805; + var $807=(($806+4)|0); + HEAPF32[(($807)>>2)]=$795; + var $808=$2; + var $809=(($808+64)|0); + var $810=HEAP32[(($809)>>2)]; + var $811=$st; + var $812=(($811+2)|0); + var $813=$812; + var $814=HEAP16[(($813)>>1)]; + var $815=(($814)&65535); + var $816=(($810+($815<<2))|0); + var $817=$816; + var $818=$817; + var $819=(($818+8)|0); + var $820=HEAPF32[(($819)>>2)]; + var $821=$2; + var $822=(($821+64)|0); + var $823=HEAP32[(($822)>>2)]; + var $824=$st; + var $825=(($824+4)|0); + var $826=$825; + var $827=HEAP16[(($826)>>1)]; + var $828=(($827)&65535); + var $829=(($823+($828<<2))|0); + var $830=$829; + var $831=$830; + var $832=(($831+8)|0); + var $833=HEAPF32[(($832)>>2)]; + var $834=($820)-($833); + var $835=$2; + var $836=(($835+64)|0); + var $837=HEAP32[(($836)>>2)]; + var $838=$st; + var $839=(($838+6)|0); + var $840=$839; + var $841=HEAP16[(($840)>>1)]; + var $842=(($841)&65535); + var $843=(($837+($842<<2))|0); + var $844=$843; + var $845=$844; + var $846=(($845+8)|0); + HEAPF32[(($846)>>2)]=$834; + __label__ = 124; break; + case 22: + var $848=$2; + var $849=(($848+64)|0); + var $850=HEAP32[(($849)>>2)]; + var $851=$st; + var $852=(($851+2)|0); + var $853=$852; + var $854=HEAP16[(($853)>>1)]; + var $855=(($854)&65535); + var $856=(($850+($855<<2))|0); + var $857=$856; + var $858=$857; + var $859=HEAPF32[(($858)>>2)]; + var $860=$2; + var $861=(($860+64)|0); + var $862=HEAP32[(($861)>>2)]; + var $863=$st; + var $864=(($863+4)|0); + var $865=$864; + var $866=HEAP16[(($865)>>1)]; + var $867=(($866)&65535); + var $868=(($862+($867<<2))|0); + var $869=$868; + var $870=$869; + var $871=HEAPF32[(($870)>>2)]; + var $872=$859 == $871; + var $873=(($872)&1); + var $874=(($873)|0); + var $875=$2; + var $876=(($875+64)|0); + var $877=HEAP32[(($876)>>2)]; + var $878=$st; + var $879=(($878+6)|0); + var $880=$879; + var $881=HEAP16[(($880)>>1)]; + var $882=(($881)&65535); + var $883=(($877+($882<<2))|0); + var $884=$883; + var $885=$884; + HEAPF32[(($885)>>2)]=$874; + __label__ = 124; break; + case 23: + var $887=$2; + var $888=(($887+64)|0); + var $889=HEAP32[(($888)>>2)]; + var $890=$st; + var $891=(($890+2)|0); + var $892=$891; + var $893=HEAP16[(($892)>>1)]; + var $894=(($893)&65535); + var $895=(($889+($894<<2))|0); + var $896=$895; + var $897=$896; + var $898=(($897)|0); + var $899=HEAPF32[(($898)>>2)]; + var $900=$2; + var $901=(($900+64)|0); + var $902=HEAP32[(($901)>>2)]; + var $903=$st; + var $904=(($903+4)|0); + var $905=$904; + var $906=HEAP16[(($905)>>1)]; + var $907=(($906)&65535); + var $908=(($902+($907<<2))|0); + var $909=$908; + var $910=$909; + var $911=(($910)|0); + var $912=HEAPF32[(($911)>>2)]; + var $913=$899 == $912; + if ($913) { __label__ = 24; break; } else { var $971 = 0;__label__ = 26; break; } + case 24: + var $915=$2; + var $916=(($915+64)|0); + var $917=HEAP32[(($916)>>2)]; + var $918=$st; + var $919=(($918+2)|0); + var $920=$919; + var $921=HEAP16[(($920)>>1)]; + var $922=(($921)&65535); + var $923=(($917+($922<<2))|0); + var $924=$923; + var $925=$924; + var $926=(($925+4)|0); + var $927=HEAPF32[(($926)>>2)]; + var $928=$2; + var $929=(($928+64)|0); + var $930=HEAP32[(($929)>>2)]; + var $931=$st; + var $932=(($931+4)|0); + var $933=$932; + var $934=HEAP16[(($933)>>1)]; + var $935=(($934)&65535); + var $936=(($930+($935<<2))|0); + var $937=$936; + var $938=$937; + var $939=(($938+4)|0); + var $940=HEAPF32[(($939)>>2)]; + var $941=$927 == $940; + if ($941) { __label__ = 25; break; } else { var $971 = 0;__label__ = 26; break; } + case 25: + var $943=$2; + var $944=(($943+64)|0); + var $945=HEAP32[(($944)>>2)]; + var $946=$st; + var $947=(($946+2)|0); + var $948=$947; + var $949=HEAP16[(($948)>>1)]; + var $950=(($949)&65535); + var $951=(($945+($950<<2))|0); + var $952=$951; + var $953=$952; + var $954=(($953+8)|0); + var $955=HEAPF32[(($954)>>2)]; + var $956=$2; + var $957=(($956+64)|0); + var $958=HEAP32[(($957)>>2)]; + var $959=$st; + var $960=(($959+4)|0); + var $961=$960; + var $962=HEAP16[(($961)>>1)]; + var $963=(($962)&65535); + var $964=(($958+($963<<2))|0); + var $965=$964; + var $966=$965; + var $967=(($966+8)|0); + var $968=HEAPF32[(($967)>>2)]; + var $969=$955 == $968; + var $971 = $969;__label__ = 26; break; + case 26: + var $971; + var $972=(($971)&1); + var $973=(($972)|0); + var $974=$2; + var $975=(($974+64)|0); + var $976=HEAP32[(($975)>>2)]; + var $977=$st; + var $978=(($977+6)|0); + var $979=$978; + var $980=HEAP16[(($979)>>1)]; + var $981=(($980)&65535); + var $982=(($976+($981<<2))|0); + var $983=$982; + var $984=$983; + HEAPF32[(($984)>>2)]=$973; + __label__ = 124; break; + case 27: + var $986=$2; + var $987=$2; + var $988=(($987+64)|0); + var $989=HEAP32[(($988)>>2)]; + var $990=$st; + var $991=(($990+2)|0); + var $992=$991; + var $993=HEAP16[(($992)>>1)]; + var $994=(($993)&65535); + var $995=(($989+($994<<2))|0); + var $996=$995; + var $997=$996; + var $998=HEAP32[(($997)>>2)]; + var $999=_prog_getstring($986, $998); + var $1000=$2; + var $1001=$2; + var $1002=(($1001+64)|0); + var $1003=HEAP32[(($1002)>>2)]; + var $1004=$st; + var $1005=(($1004+4)|0); + var $1006=$1005; + var $1007=HEAP16[(($1006)>>1)]; + var $1008=(($1007)&65535); + var $1009=(($1003+($1008<<2))|0); + var $1010=$1009; + var $1011=$1010; + var $1012=HEAP32[(($1011)>>2)]; + var $1013=_prog_getstring($1000, $1012); + var $1014=_strcmp($999, $1013); + var $1015=(($1014)|0)!=0; + var $1016=$1015 ^ 1; + var $1017=(($1016)&1); + var $1018=(($1017)|0); + var $1019=$2; + var $1020=(($1019+64)|0); + var $1021=HEAP32[(($1020)>>2)]; + var $1022=$st; + var $1023=(($1022+6)|0); + var $1024=$1023; + var $1025=HEAP16[(($1024)>>1)]; + var $1026=(($1025)&65535); + var $1027=(($1021+($1026<<2))|0); + var $1028=$1027; + var $1029=$1028; + HEAPF32[(($1029)>>2)]=$1018; + __label__ = 124; break; + case 28: + var $1031=$2; + var $1032=(($1031+64)|0); + var $1033=HEAP32[(($1032)>>2)]; + var $1034=$st; + var $1035=(($1034+2)|0); + var $1036=$1035; + var $1037=HEAP16[(($1036)>>1)]; + var $1038=(($1037)&65535); + var $1039=(($1033+($1038<<2))|0); + var $1040=$1039; + var $1041=$1040; + var $1042=HEAP32[(($1041)>>2)]; + var $1043=$2; + var $1044=(($1043+64)|0); + var $1045=HEAP32[(($1044)>>2)]; + var $1046=$st; + var $1047=(($1046+4)|0); + var $1048=$1047; + var $1049=HEAP16[(($1048)>>1)]; + var $1050=(($1049)&65535); + var $1051=(($1045+($1050<<2))|0); + var $1052=$1051; + var $1053=$1052; + var $1054=HEAP32[(($1053)>>2)]; + var $1055=(($1042)|0)==(($1054)|0); + var $1056=(($1055)&1); + var $1057=(($1056)|0); + var $1058=$2; + var $1059=(($1058+64)|0); + var $1060=HEAP32[(($1059)>>2)]; + var $1061=$st; + var $1062=(($1061+6)|0); + var $1063=$1062; + var $1064=HEAP16[(($1063)>>1)]; + var $1065=(($1064)&65535); + var $1066=(($1060+($1065<<2))|0); + var $1067=$1066; + var $1068=$1067; + HEAPF32[(($1068)>>2)]=$1057; + __label__ = 124; break; + case 29: + var $1070=$2; + var $1071=(($1070+64)|0); + var $1072=HEAP32[(($1071)>>2)]; + var $1073=$st; + var $1074=(($1073+2)|0); + var $1075=$1074; + var $1076=HEAP16[(($1075)>>1)]; + var $1077=(($1076)&65535); + var $1078=(($1072+($1077<<2))|0); + var $1079=$1078; + var $1080=$1079; + var $1081=HEAP32[(($1080)>>2)]; + var $1082=$2; + var $1083=(($1082+64)|0); + var $1084=HEAP32[(($1083)>>2)]; + var $1085=$st; + var $1086=(($1085+4)|0); + var $1087=$1086; + var $1088=HEAP16[(($1087)>>1)]; + var $1089=(($1088)&65535); + var $1090=(($1084+($1089<<2))|0); + var $1091=$1090; + var $1092=$1091; + var $1093=HEAP32[(($1092)>>2)]; + var $1094=(($1081)|0)==(($1093)|0); + var $1095=(($1094)&1); + var $1096=(($1095)|0); + var $1097=$2; + var $1098=(($1097+64)|0); + var $1099=HEAP32[(($1098)>>2)]; + var $1100=$st; + var $1101=(($1100+6)|0); + var $1102=$1101; + var $1103=HEAP16[(($1102)>>1)]; + var $1104=(($1103)&65535); + var $1105=(($1099+($1104<<2))|0); + var $1106=$1105; + var $1107=$1106; + HEAPF32[(($1107)>>2)]=$1096; + __label__ = 124; break; + case 30: + var $1109=$2; + var $1110=(($1109+64)|0); + var $1111=HEAP32[(($1110)>>2)]; + var $1112=$st; + var $1113=(($1112+2)|0); + var $1114=$1113; + var $1115=HEAP16[(($1114)>>1)]; + var $1116=(($1115)&65535); + var $1117=(($1111+($1116<<2))|0); + var $1118=$1117; + var $1119=$1118; + var $1120=HEAPF32[(($1119)>>2)]; + var $1121=$2; + var $1122=(($1121+64)|0); + var $1123=HEAP32[(($1122)>>2)]; + var $1124=$st; + var $1125=(($1124+4)|0); + var $1126=$1125; + var $1127=HEAP16[(($1126)>>1)]; + var $1128=(($1127)&65535); + var $1129=(($1123+($1128<<2))|0); + var $1130=$1129; + var $1131=$1130; + var $1132=HEAPF32[(($1131)>>2)]; + var $1133=$1120 != $1132; + var $1134=(($1133)&1); + var $1135=(($1134)|0); + var $1136=$2; + var $1137=(($1136+64)|0); + var $1138=HEAP32[(($1137)>>2)]; + var $1139=$st; + var $1140=(($1139+6)|0); + var $1141=$1140; + var $1142=HEAP16[(($1141)>>1)]; + var $1143=(($1142)&65535); + var $1144=(($1138+($1143<<2))|0); + var $1145=$1144; + var $1146=$1145; + HEAPF32[(($1146)>>2)]=$1135; + __label__ = 124; break; + case 31: + var $1148=$2; + var $1149=(($1148+64)|0); + var $1150=HEAP32[(($1149)>>2)]; + var $1151=$st; + var $1152=(($1151+2)|0); + var $1153=$1152; + var $1154=HEAP16[(($1153)>>1)]; + var $1155=(($1154)&65535); + var $1156=(($1150+($1155<<2))|0); + var $1157=$1156; + var $1158=$1157; + var $1159=(($1158)|0); + var $1160=HEAPF32[(($1159)>>2)]; + var $1161=$2; + var $1162=(($1161+64)|0); + var $1163=HEAP32[(($1162)>>2)]; + var $1164=$st; + var $1165=(($1164+4)|0); + var $1166=$1165; + var $1167=HEAP16[(($1166)>>1)]; + var $1168=(($1167)&65535); + var $1169=(($1163+($1168<<2))|0); + var $1170=$1169; + var $1171=$1170; + var $1172=(($1171)|0); + var $1173=HEAPF32[(($1172)>>2)]; + var $1174=$1160 != $1173; + if ($1174) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 32; break; } + case 32: + var $1176=$2; + var $1177=(($1176+64)|0); + var $1178=HEAP32[(($1177)>>2)]; + var $1179=$st; + var $1180=(($1179+2)|0); + var $1181=$1180; + var $1182=HEAP16[(($1181)>>1)]; + var $1183=(($1182)&65535); + var $1184=(($1178+($1183<<2))|0); + var $1185=$1184; + var $1186=$1185; + var $1187=(($1186+4)|0); + var $1188=HEAPF32[(($1187)>>2)]; + var $1189=$2; + var $1190=(($1189+64)|0); + var $1191=HEAP32[(($1190)>>2)]; + var $1192=$st; + var $1193=(($1192+4)|0); + var $1194=$1193; + var $1195=HEAP16[(($1194)>>1)]; + var $1196=(($1195)&65535); + var $1197=(($1191+($1196<<2))|0); + var $1198=$1197; + var $1199=$1198; + var $1200=(($1199+4)|0); + var $1201=HEAPF32[(($1200)>>2)]; + var $1202=$1188 != $1201; + if ($1202) { var $1232 = 1;__label__ = 34; break; } else { __label__ = 33; break; } + case 33: + var $1204=$2; + var $1205=(($1204+64)|0); + var $1206=HEAP32[(($1205)>>2)]; + var $1207=$st; + var $1208=(($1207+2)|0); + var $1209=$1208; + var $1210=HEAP16[(($1209)>>1)]; + var $1211=(($1210)&65535); + var $1212=(($1206+($1211<<2))|0); + var $1213=$1212; + var $1214=$1213; + var $1215=(($1214+8)|0); + var $1216=HEAPF32[(($1215)>>2)]; + var $1217=$2; + var $1218=(($1217+64)|0); + var $1219=HEAP32[(($1218)>>2)]; + var $1220=$st; + var $1221=(($1220+4)|0); + var $1222=$1221; + var $1223=HEAP16[(($1222)>>1)]; + var $1224=(($1223)&65535); + var $1225=(($1219+($1224<<2))|0); + var $1226=$1225; + var $1227=$1226; + var $1228=(($1227+8)|0); + var $1229=HEAPF32[(($1228)>>2)]; + var $1230=$1216 != $1229; + var $1232 = $1230;__label__ = 34; break; + case 34: + var $1232; + var $1233=(($1232)&1); + var $1234=(($1233)|0); + var $1235=$2; + var $1236=(($1235+64)|0); + var $1237=HEAP32[(($1236)>>2)]; + var $1238=$st; + var $1239=(($1238+6)|0); + var $1240=$1239; + var $1241=HEAP16[(($1240)>>1)]; + var $1242=(($1241)&65535); + var $1243=(($1237+($1242<<2))|0); + var $1244=$1243; + var $1245=$1244; + HEAPF32[(($1245)>>2)]=$1234; + __label__ = 124; break; + case 35: + var $1247=$2; + var $1248=$2; + var $1249=(($1248+64)|0); + var $1250=HEAP32[(($1249)>>2)]; + var $1251=$st; + var $1252=(($1251+2)|0); + var $1253=$1252; + var $1254=HEAP16[(($1253)>>1)]; + var $1255=(($1254)&65535); + var $1256=(($1250+($1255<<2))|0); + var $1257=$1256; + var $1258=$1257; + var $1259=HEAP32[(($1258)>>2)]; + var $1260=_prog_getstring($1247, $1259); + var $1261=$2; + var $1262=$2; + var $1263=(($1262+64)|0); + var $1264=HEAP32[(($1263)>>2)]; + var $1265=$st; + var $1266=(($1265+4)|0); + var $1267=$1266; + var $1268=HEAP16[(($1267)>>1)]; + var $1269=(($1268)&65535); + var $1270=(($1264+($1269<<2))|0); + var $1271=$1270; + var $1272=$1271; + var $1273=HEAP32[(($1272)>>2)]; + var $1274=_prog_getstring($1261, $1273); + var $1275=_strcmp($1260, $1274); + var $1276=(($1275)|0)!=0; + var $1277=$1276 ^ 1; + var $1278=$1277 ^ 1; + var $1279=(($1278)&1); + var $1280=(($1279)|0); + var $1281=$2; + var $1282=(($1281+64)|0); + var $1283=HEAP32[(($1282)>>2)]; + var $1284=$st; + var $1285=(($1284+6)|0); + var $1286=$1285; + var $1287=HEAP16[(($1286)>>1)]; + var $1288=(($1287)&65535); + var $1289=(($1283+($1288<<2))|0); + var $1290=$1289; + var $1291=$1290; + HEAPF32[(($1291)>>2)]=$1280; + __label__ = 124; break; + case 36: + var $1293=$2; + var $1294=(($1293+64)|0); + var $1295=HEAP32[(($1294)>>2)]; + var $1296=$st; + var $1297=(($1296+2)|0); + var $1298=$1297; + var $1299=HEAP16[(($1298)>>1)]; + var $1300=(($1299)&65535); + var $1301=(($1295+($1300<<2))|0); + var $1302=$1301; + var $1303=$1302; + var $1304=HEAP32[(($1303)>>2)]; + var $1305=$2; + var $1306=(($1305+64)|0); + var $1307=HEAP32[(($1306)>>2)]; + var $1308=$st; + var $1309=(($1308+4)|0); + var $1310=$1309; + var $1311=HEAP16[(($1310)>>1)]; + var $1312=(($1311)&65535); + var $1313=(($1307+($1312<<2))|0); + var $1314=$1313; + var $1315=$1314; + var $1316=HEAP32[(($1315)>>2)]; + var $1317=(($1304)|0)!=(($1316)|0); + var $1318=(($1317)&1); + var $1319=(($1318)|0); + var $1320=$2; + var $1321=(($1320+64)|0); + var $1322=HEAP32[(($1321)>>2)]; + var $1323=$st; + var $1324=(($1323+6)|0); + var $1325=$1324; + var $1326=HEAP16[(($1325)>>1)]; + var $1327=(($1326)&65535); + var $1328=(($1322+($1327<<2))|0); + var $1329=$1328; + var $1330=$1329; + HEAPF32[(($1330)>>2)]=$1319; + __label__ = 124; break; + case 37: + var $1332=$2; + var $1333=(($1332+64)|0); + var $1334=HEAP32[(($1333)>>2)]; + var $1335=$st; + var $1336=(($1335+2)|0); + var $1337=$1336; + var $1338=HEAP16[(($1337)>>1)]; + var $1339=(($1338)&65535); + var $1340=(($1334+($1339<<2))|0); + var $1341=$1340; + var $1342=$1341; + var $1343=HEAP32[(($1342)>>2)]; + var $1344=$2; + var $1345=(($1344+64)|0); + var $1346=HEAP32[(($1345)>>2)]; + var $1347=$st; + var $1348=(($1347+4)|0); + var $1349=$1348; + var $1350=HEAP16[(($1349)>>1)]; + var $1351=(($1350)&65535); + var $1352=(($1346+($1351<<2))|0); + var $1353=$1352; + var $1354=$1353; + var $1355=HEAP32[(($1354)>>2)]; + var $1356=(($1343)|0)!=(($1355)|0); + var $1357=(($1356)&1); + var $1358=(($1357)|0); + var $1359=$2; + var $1360=(($1359+64)|0); + var $1361=HEAP32[(($1360)>>2)]; + var $1362=$st; + var $1363=(($1362+6)|0); + var $1364=$1363; + var $1365=HEAP16[(($1364)>>1)]; + var $1366=(($1365)&65535); + var $1367=(($1361+($1366<<2))|0); + var $1368=$1367; + var $1369=$1368; + HEAPF32[(($1369)>>2)]=$1358; + __label__ = 124; break; + case 38: + var $1371=$2; + var $1372=(($1371+64)|0); + var $1373=HEAP32[(($1372)>>2)]; + var $1374=$st; + var $1375=(($1374+2)|0); + var $1376=$1375; + var $1377=HEAP16[(($1376)>>1)]; + var $1378=(($1377)&65535); + var $1379=(($1373+($1378<<2))|0); + var $1380=$1379; + var $1381=$1380; + var $1382=HEAPF32[(($1381)>>2)]; + var $1383=$2; + var $1384=(($1383+64)|0); + var $1385=HEAP32[(($1384)>>2)]; + var $1386=$st; + var $1387=(($1386+4)|0); + var $1388=$1387; + var $1389=HEAP16[(($1388)>>1)]; + var $1390=(($1389)&65535); + var $1391=(($1385+($1390<<2))|0); + var $1392=$1391; + var $1393=$1392; + var $1394=HEAPF32[(($1393)>>2)]; + var $1395=$1382 <= $1394; + var $1396=(($1395)&1); + var $1397=(($1396)|0); + var $1398=$2; + var $1399=(($1398+64)|0); + var $1400=HEAP32[(($1399)>>2)]; + var $1401=$st; + var $1402=(($1401+6)|0); + var $1403=$1402; + var $1404=HEAP16[(($1403)>>1)]; + var $1405=(($1404)&65535); + var $1406=(($1400+($1405<<2))|0); + var $1407=$1406; + var $1408=$1407; + HEAPF32[(($1408)>>2)]=$1397; + __label__ = 124; break; + case 39: + var $1410=$2; + var $1411=(($1410+64)|0); + var $1412=HEAP32[(($1411)>>2)]; + var $1413=$st; + var $1414=(($1413+2)|0); + var $1415=$1414; + var $1416=HEAP16[(($1415)>>1)]; + var $1417=(($1416)&65535); + var $1418=(($1412+($1417<<2))|0); + var $1419=$1418; + var $1420=$1419; + var $1421=HEAPF32[(($1420)>>2)]; + var $1422=$2; + var $1423=(($1422+64)|0); + var $1424=HEAP32[(($1423)>>2)]; + var $1425=$st; + var $1426=(($1425+4)|0); + var $1427=$1426; + var $1428=HEAP16[(($1427)>>1)]; + var $1429=(($1428)&65535); + var $1430=(($1424+($1429<<2))|0); + var $1431=$1430; + var $1432=$1431; + var $1433=HEAPF32[(($1432)>>2)]; + var $1434=$1421 >= $1433; + var $1435=(($1434)&1); + var $1436=(($1435)|0); + var $1437=$2; + var $1438=(($1437+64)|0); + var $1439=HEAP32[(($1438)>>2)]; + var $1440=$st; + var $1441=(($1440+6)|0); + var $1442=$1441; + var $1443=HEAP16[(($1442)>>1)]; + var $1444=(($1443)&65535); + var $1445=(($1439+($1444<<2))|0); + var $1446=$1445; + var $1447=$1446; + HEAPF32[(($1447)>>2)]=$1436; + __label__ = 124; break; + case 40: + var $1449=$2; + var $1450=(($1449+64)|0); + var $1451=HEAP32[(($1450)>>2)]; + var $1452=$st; + var $1453=(($1452+2)|0); + var $1454=$1453; + var $1455=HEAP16[(($1454)>>1)]; + var $1456=(($1455)&65535); + var $1457=(($1451+($1456<<2))|0); + var $1458=$1457; + var $1459=$1458; + var $1460=HEAPF32[(($1459)>>2)]; + var $1461=$2; + var $1462=(($1461+64)|0); + var $1463=HEAP32[(($1462)>>2)]; + var $1464=$st; + var $1465=(($1464+4)|0); + var $1466=$1465; + var $1467=HEAP16[(($1466)>>1)]; + var $1468=(($1467)&65535); + var $1469=(($1463+($1468<<2))|0); + var $1470=$1469; + var $1471=$1470; + var $1472=HEAPF32[(($1471)>>2)]; + var $1473=$1460 < $1472; + var $1474=(($1473)&1); + var $1475=(($1474)|0); + var $1476=$2; + var $1477=(($1476+64)|0); + var $1478=HEAP32[(($1477)>>2)]; + var $1479=$st; + var $1480=(($1479+6)|0); + var $1481=$1480; + var $1482=HEAP16[(($1481)>>1)]; + var $1483=(($1482)&65535); + var $1484=(($1478+($1483<<2))|0); + var $1485=$1484; + var $1486=$1485; + HEAPF32[(($1486)>>2)]=$1475; + __label__ = 124; break; + case 41: + var $1488=$2; + var $1489=(($1488+64)|0); + var $1490=HEAP32[(($1489)>>2)]; + var $1491=$st; + var $1492=(($1491+2)|0); + var $1493=$1492; + var $1494=HEAP16[(($1493)>>1)]; + var $1495=(($1494)&65535); + var $1496=(($1490+($1495<<2))|0); + var $1497=$1496; + var $1498=$1497; + var $1499=HEAPF32[(($1498)>>2)]; + var $1500=$2; + var $1501=(($1500+64)|0); + var $1502=HEAP32[(($1501)>>2)]; + var $1503=$st; + var $1504=(($1503+4)|0); + var $1505=$1504; + var $1506=HEAP16[(($1505)>>1)]; + var $1507=(($1506)&65535); + var $1508=(($1502+($1507<<2))|0); + var $1509=$1508; + var $1510=$1509; + var $1511=HEAPF32[(($1510)>>2)]; + var $1512=$1499 > $1511; + var $1513=(($1512)&1); + var $1514=(($1513)|0); + var $1515=$2; + var $1516=(($1515+64)|0); + var $1517=HEAP32[(($1516)>>2)]; + var $1518=$st; + var $1519=(($1518+6)|0); + var $1520=$1519; + var $1521=HEAP16[(($1520)>>1)]; + var $1522=(($1521)&65535); + var $1523=(($1517+($1522<<2))|0); + var $1524=$1523; + var $1525=$1524; + HEAPF32[(($1525)>>2)]=$1514; + __label__ = 124; break; + case 42: + var $1527=$2; + var $1528=(($1527+64)|0); + var $1529=HEAP32[(($1528)>>2)]; + var $1530=$st; + var $1531=(($1530+2)|0); + var $1532=$1531; + var $1533=HEAP16[(($1532)>>1)]; + var $1534=(($1533)&65535); + var $1535=(($1529+($1534<<2))|0); + var $1536=$1535; + var $1537=$1536; + var $1538=HEAP32[(($1537)>>2)]; + var $1539=(($1538)|0) < 0; + if ($1539) { __label__ = 44; break; } else { __label__ = 43; break; } + case 43: + var $1541=$2; + var $1542=(($1541+64)|0); + var $1543=HEAP32[(($1542)>>2)]; + var $1544=$st; + var $1545=(($1544+2)|0); + var $1546=$1545; + var $1547=HEAP16[(($1546)>>1)]; + var $1548=(($1547)&65535); + var $1549=(($1543+($1548<<2))|0); + var $1550=$1549; + var $1551=$1550; + var $1552=HEAP32[(($1551)>>2)]; + var $1553=$2; + var $1554=(($1553+140)|0); + var $1555=HEAP32[(($1554)>>2)]; + var $1556=(($1552)|0) >= (($1555)|0); + if ($1556) { __label__ = 44; break; } else { __label__ = 45; break; } + case 44: + var $1558=$2; + var $1559=$2; + var $1560=(($1559)|0); + var $1561=HEAP32[(($1560)>>2)]; + _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)); + __label__ = 488; break; + case 45: + var $1563=$2; + var $1564=(($1563+64)|0); + var $1565=HEAP32[(($1564)>>2)]; + var $1566=$st; + var $1567=(($1566+4)|0); + var $1568=$1567; + var $1569=HEAP16[(($1568)>>1)]; + var $1570=(($1569)&65535); + var $1571=(($1565+($1570<<2))|0); + var $1572=$1571; + var $1573=$1572; + var $1574=HEAP32[(($1573)>>2)]; + var $1575=$2; + var $1576=(($1575+144)|0); + var $1577=HEAP32[(($1576)>>2)]; + var $1578=(($1574)>>>0) >= (($1577)>>>0); + if ($1578) { __label__ = 46; break; } else { __label__ = 47; break; } + case 46: + var $1580=$2; + var $1581=$2; + var $1582=(($1581)|0); + var $1583=HEAP32[(($1582)>>2)]; + var $1584=$2; + var $1585=(($1584+64)|0); + var $1586=HEAP32[(($1585)>>2)]; + var $1587=$st; + var $1588=(($1587+4)|0); + var $1589=$1588; + var $1590=HEAP16[(($1589)>>1)]; + var $1591=(($1590)&65535); + var $1592=(($1586+($1591<<2))|0); + var $1593=$1592; + var $1594=$1593; + var $1595=HEAP32[(($1594)>>2)]; + _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)); + __label__ = 488; break; + case 47: + var $1597=$2; + var $1598=$2; + var $1599=(($1598+64)|0); + var $1600=HEAP32[(($1599)>>2)]; + var $1601=$st; + var $1602=(($1601+2)|0); + var $1603=$1602; + var $1604=HEAP16[(($1603)>>1)]; + var $1605=(($1604)&65535); + var $1606=(($1600+($1605<<2))|0); + var $1607=$1606; + var $1608=$1607; + var $1609=HEAP32[(($1608)>>2)]; + var $1610=_prog_getedict($1597, $1609); + $ed=$1610; + var $1611=$ed; + var $1612=$1611; + var $1613=$2; + var $1614=(($1613+64)|0); + var $1615=HEAP32[(($1614)>>2)]; + var $1616=$st; + var $1617=(($1616+4)|0); + var $1618=$1617; + var $1619=HEAP16[(($1618)>>1)]; + var $1620=(($1619)&65535); + var $1621=(($1615+($1620<<2))|0); + var $1622=$1621; + var $1623=$1622; + var $1624=HEAP32[(($1623)>>2)]; + var $1625=(($1612+($1624<<2))|0); + var $1626=$1625; + var $1627=$1626; + var $1628=HEAP32[(($1627)>>2)]; + var $1629=$2; + var $1630=(($1629+64)|0); + var $1631=HEAP32[(($1630)>>2)]; + var $1632=$st; + var $1633=(($1632+6)|0); + var $1634=$1633; + var $1635=HEAP16[(($1634)>>1)]; + var $1636=(($1635)&65535); + var $1637=(($1631+($1636<<2))|0); + var $1638=$1637; + var $1639=$1638; + HEAP32[(($1639)>>2)]=$1628; + __label__ = 124; break; + case 48: + var $1641=$2; + var $1642=(($1641+64)|0); + var $1643=HEAP32[(($1642)>>2)]; + var $1644=$st; + var $1645=(($1644+2)|0); + var $1646=$1645; + var $1647=HEAP16[(($1646)>>1)]; + var $1648=(($1647)&65535); + var $1649=(($1643+($1648<<2))|0); + var $1650=$1649; + var $1651=$1650; + var $1652=HEAP32[(($1651)>>2)]; + var $1653=(($1652)|0) < 0; + if ($1653) { __label__ = 50; break; } else { __label__ = 49; break; } + case 49: + var $1655=$2; + var $1656=(($1655+64)|0); + var $1657=HEAP32[(($1656)>>2)]; + var $1658=$st; + var $1659=(($1658+2)|0); + var $1660=$1659; + var $1661=HEAP16[(($1660)>>1)]; + var $1662=(($1661)&65535); + var $1663=(($1657+($1662<<2))|0); + var $1664=$1663; + var $1665=$1664; + var $1666=HEAP32[(($1665)>>2)]; + var $1667=$2; + var $1668=(($1667+140)|0); + var $1669=HEAP32[(($1668)>>2)]; + var $1670=(($1666)|0) >= (($1669)|0); + if ($1670) { __label__ = 50; break; } else { __label__ = 51; break; } + case 50: + var $1672=$2; + var $1673=$2; + var $1674=(($1673)|0); + var $1675=HEAP32[(($1674)>>2)]; + _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)); + __label__ = 488; break; + case 51: + var $1677=$2; + var $1678=(($1677+64)|0); + var $1679=HEAP32[(($1678)>>2)]; + var $1680=$st; + var $1681=(($1680+4)|0); + var $1682=$1681; + var $1683=HEAP16[(($1682)>>1)]; + var $1684=(($1683)&65535); + var $1685=(($1679+($1684<<2))|0); + var $1686=$1685; + var $1687=$1686; + var $1688=HEAP32[(($1687)>>2)]; + var $1689=(($1688)|0) < 0; + if ($1689) { __label__ = 53; break; } else { __label__ = 52; break; } + case 52: + var $1691=$2; + var $1692=(($1691+64)|0); + var $1693=HEAP32[(($1692)>>2)]; + var $1694=$st; + var $1695=(($1694+4)|0); + var $1696=$1695; + var $1697=HEAP16[(($1696)>>1)]; + var $1698=(($1697)&65535); + var $1699=(($1693+($1698<<2))|0); + var $1700=$1699; + var $1701=$1700; + var $1702=HEAP32[(($1701)>>2)]; + var $1703=((($1702)+(3))|0); + var $1704=$2; + var $1705=(($1704+144)|0); + var $1706=HEAP32[(($1705)>>2)]; + var $1707=(($1703)>>>0) > (($1706)>>>0); + if ($1707) { __label__ = 53; break; } else { __label__ = 54; break; } + case 53: + var $1709=$2; + var $1710=$2; + var $1711=(($1710)|0); + var $1712=HEAP32[(($1711)>>2)]; + var $1713=$2; + var $1714=(($1713+64)|0); + var $1715=HEAP32[(($1714)>>2)]; + var $1716=$st; + var $1717=(($1716+4)|0); + var $1718=$1717; + var $1719=HEAP16[(($1718)>>1)]; + var $1720=(($1719)&65535); + var $1721=(($1715+($1720<<2))|0); + var $1722=$1721; + var $1723=$1722; + var $1724=HEAP32[(($1723)>>2)]; + var $1725=((($1724)+(2))|0); + _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)); + __label__ = 488; break; + case 54: + var $1727=$2; + var $1728=$2; + var $1729=(($1728+64)|0); + var $1730=HEAP32[(($1729)>>2)]; + var $1731=$st; + var $1732=(($1731+2)|0); + var $1733=$1732; + var $1734=HEAP16[(($1733)>>1)]; + var $1735=(($1734)&65535); + var $1736=(($1730+($1735<<2))|0); + var $1737=$1736; + var $1738=$1737; + var $1739=HEAP32[(($1738)>>2)]; + var $1740=_prog_getedict($1727, $1739); + $ed=$1740; + var $1741=$ed; + var $1742=$1741; + var $1743=$2; + var $1744=(($1743+64)|0); + var $1745=HEAP32[(($1744)>>2)]; + var $1746=$st; + var $1747=(($1746+4)|0); + var $1748=$1747; + var $1749=HEAP16[(($1748)>>1)]; + var $1750=(($1749)&65535); + var $1751=(($1745+($1750<<2))|0); + var $1752=$1751; + var $1753=$1752; + var $1754=HEAP32[(($1753)>>2)]; + var $1755=(($1742+($1754<<2))|0); + var $1756=$1755; + var $1757=$1756; + var $1758=(($1757)|0); + var $1759=HEAP32[(($1758)>>2)]; + var $1760=$2; + var $1761=(($1760+64)|0); + var $1762=HEAP32[(($1761)>>2)]; + var $1763=$st; + var $1764=(($1763+6)|0); + var $1765=$1764; + var $1766=HEAP16[(($1765)>>1)]; + var $1767=(($1766)&65535); + var $1768=(($1762+($1767<<2))|0); + var $1769=$1768; + var $1770=$1769; + var $1771=(($1770)|0); + HEAP32[(($1771)>>2)]=$1759; + var $1772=$ed; + var $1773=$1772; + var $1774=$2; + var $1775=(($1774+64)|0); + var $1776=HEAP32[(($1775)>>2)]; + var $1777=$st; + var $1778=(($1777+4)|0); + var $1779=$1778; + var $1780=HEAP16[(($1779)>>1)]; + var $1781=(($1780)&65535); + var $1782=(($1776+($1781<<2))|0); + var $1783=$1782; + var $1784=$1783; + var $1785=HEAP32[(($1784)>>2)]; + var $1786=(($1773+($1785<<2))|0); + var $1787=$1786; + var $1788=$1787; + var $1789=(($1788+4)|0); + var $1790=HEAP32[(($1789)>>2)]; + var $1791=$2; + var $1792=(($1791+64)|0); + var $1793=HEAP32[(($1792)>>2)]; + var $1794=$st; + var $1795=(($1794+6)|0); + var $1796=$1795; + var $1797=HEAP16[(($1796)>>1)]; + var $1798=(($1797)&65535); + var $1799=(($1793+($1798<<2))|0); + var $1800=$1799; + var $1801=$1800; + var $1802=(($1801+4)|0); + HEAP32[(($1802)>>2)]=$1790; + var $1803=$ed; + var $1804=$1803; + var $1805=$2; + var $1806=(($1805+64)|0); + var $1807=HEAP32[(($1806)>>2)]; + var $1808=$st; + var $1809=(($1808+4)|0); + var $1810=$1809; + var $1811=HEAP16[(($1810)>>1)]; + var $1812=(($1811)&65535); + var $1813=(($1807+($1812<<2))|0); + var $1814=$1813; + var $1815=$1814; + var $1816=HEAP32[(($1815)>>2)]; + var $1817=(($1804+($1816<<2))|0); + var $1818=$1817; + var $1819=$1818; + var $1820=(($1819+8)|0); + var $1821=HEAP32[(($1820)>>2)]; + var $1822=$2; + var $1823=(($1822+64)|0); + var $1824=HEAP32[(($1823)>>2)]; + var $1825=$st; + var $1826=(($1825+6)|0); + var $1827=$1826; + var $1828=HEAP16[(($1827)>>1)]; + var $1829=(($1828)&65535); + var $1830=(($1824+($1829<<2))|0); + var $1831=$1830; + var $1832=$1831; + var $1833=(($1832+8)|0); + HEAP32[(($1833)>>2)]=$1821; + __label__ = 124; break; + case 55: + var $1835=$2; + var $1836=(($1835+64)|0); + var $1837=HEAP32[(($1836)>>2)]; + var $1838=$st; + var $1839=(($1838+2)|0); + var $1840=$1839; + var $1841=HEAP16[(($1840)>>1)]; + var $1842=(($1841)&65535); + var $1843=(($1837+($1842<<2))|0); + var $1844=$1843; + var $1845=$1844; + var $1846=HEAP32[(($1845)>>2)]; + var $1847=(($1846)|0) < 0; + if ($1847) { __label__ = 57; break; } else { __label__ = 56; break; } + case 56: + var $1849=$2; + var $1850=(($1849+64)|0); + var $1851=HEAP32[(($1850)>>2)]; + var $1852=$st; + var $1853=(($1852+2)|0); + var $1854=$1853; + var $1855=HEAP16[(($1854)>>1)]; + var $1856=(($1855)&65535); + var $1857=(($1851+($1856<<2))|0); + var $1858=$1857; + var $1859=$1858; + var $1860=HEAP32[(($1859)>>2)]; + var $1861=$2; + var $1862=(($1861+140)|0); + var $1863=HEAP32[(($1862)>>2)]; + var $1864=(($1860)|0) >= (($1863)|0); + if ($1864) { __label__ = 57; break; } else { __label__ = 58; break; } + case 57: + var $1866=$2; + var $1867=$2; + var $1868=(($1867)|0); + var $1869=HEAP32[(($1868)>>2)]; + var $1870=$2; + var $1871=(($1870+64)|0); + var $1872=HEAP32[(($1871)>>2)]; + var $1873=$st; + var $1874=(($1873+2)|0); + var $1875=$1874; + var $1876=HEAP16[(($1875)>>1)]; + var $1877=(($1876)&65535); + var $1878=(($1872+($1877<<2))|0); + var $1879=$1878; + var $1880=$1879; + var $1881=HEAP32[(($1880)>>2)]; + _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)); + __label__ = 488; break; + case 58: + var $1883=$2; + var $1884=(($1883+64)|0); + var $1885=HEAP32[(($1884)>>2)]; + var $1886=$st; + var $1887=(($1886+4)|0); + var $1888=$1887; + var $1889=HEAP16[(($1888)>>1)]; + var $1890=(($1889)&65535); + var $1891=(($1885+($1890<<2))|0); + var $1892=$1891; + var $1893=$1892; + var $1894=HEAP32[(($1893)>>2)]; + var $1895=$2; + var $1896=(($1895+144)|0); + var $1897=HEAP32[(($1896)>>2)]; + var $1898=(($1894)>>>0) >= (($1897)>>>0); + if ($1898) { __label__ = 59; break; } else { __label__ = 60; break; } + case 59: + var $1900=$2; + var $1901=$2; + var $1902=(($1901)|0); + var $1903=HEAP32[(($1902)>>2)]; + var $1904=$2; + var $1905=(($1904+64)|0); + var $1906=HEAP32[(($1905)>>2)]; + var $1907=$st; + var $1908=(($1907+4)|0); + var $1909=$1908; + var $1910=HEAP16[(($1909)>>1)]; + var $1911=(($1910)&65535); + var $1912=(($1906+($1911<<2))|0); + var $1913=$1912; + var $1914=$1913; + var $1915=HEAP32[(($1914)>>2)]; + _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)); + __label__ = 488; break; + case 60: + var $1917=$2; + var $1918=$2; + var $1919=(($1918+64)|0); + var $1920=HEAP32[(($1919)>>2)]; + var $1921=$st; + var $1922=(($1921+2)|0); + var $1923=$1922; + var $1924=HEAP16[(($1923)>>1)]; + var $1925=(($1924)&65535); + var $1926=(($1920+($1925<<2))|0); + var $1927=$1926; + var $1928=$1927; + var $1929=HEAP32[(($1928)>>2)]; + var $1930=_prog_getedict($1917, $1929); + $ed=$1930; + var $1931=$ed; + var $1932=$1931; + var $1933=$2; + var $1934=(($1933+76)|0); + var $1935=HEAP32[(($1934)>>2)]; + var $1936=$1932; + var $1937=$1935; + var $1938=((($1936)-($1937))|0); + var $1939=((((($1938)|0))/(4))&-1); + var $1940=$2; + var $1941=(($1940+64)|0); + var $1942=HEAP32[(($1941)>>2)]; + var $1943=$st; + var $1944=(($1943+6)|0); + var $1945=$1944; + var $1946=HEAP16[(($1945)>>1)]; + var $1947=(($1946)&65535); + var $1948=(($1942+($1947<<2))|0); + var $1949=$1948; + var $1950=$1949; + HEAP32[(($1950)>>2)]=$1939; + var $1951=$2; + var $1952=(($1951+64)|0); + var $1953=HEAP32[(($1952)>>2)]; + var $1954=$st; + var $1955=(($1954+4)|0); + var $1956=$1955; + var $1957=HEAP16[(($1956)>>1)]; + var $1958=(($1957)&65535); + var $1959=(($1953+($1958<<2))|0); + var $1960=$1959; + var $1961=$1960; + var $1962=HEAP32[(($1961)>>2)]; + var $1963=$2; + var $1964=(($1963+64)|0); + var $1965=HEAP32[(($1964)>>2)]; + var $1966=$st; + var $1967=(($1966+6)|0); + var $1968=$1967; + var $1969=HEAP16[(($1968)>>1)]; + var $1970=(($1969)&65535); + var $1971=(($1965+($1970<<2))|0); + var $1972=$1971; + var $1973=$1972; + var $1974=HEAP32[(($1973)>>2)]; + var $1975=((($1974)+($1962))|0); + HEAP32[(($1973)>>2)]=$1975; + __label__ = 124; break; + case 61: + var $1977=$2; + var $1978=(($1977+64)|0); + var $1979=HEAP32[(($1978)>>2)]; + var $1980=$st; + var $1981=(($1980+2)|0); + var $1982=$1981; + var $1983=HEAP16[(($1982)>>1)]; + var $1984=(($1983)&65535); + var $1985=(($1979+($1984<<2))|0); + var $1986=$1985; + var $1987=$1986; + var $1988=HEAP32[(($1987)>>2)]; + var $1989=$2; + var $1990=(($1989+64)|0); + var $1991=HEAP32[(($1990)>>2)]; + var $1992=$st; + var $1993=(($1992+4)|0); + var $1994=$1993; + var $1995=HEAP16[(($1994)>>1)]; + var $1996=(($1995)&65535); + var $1997=(($1991+($1996<<2))|0); + var $1998=$1997; + var $1999=$1998; + HEAP32[(($1999)>>2)]=$1988; + __label__ = 124; break; + case 62: + var $2001=$2; + var $2002=(($2001+64)|0); + var $2003=HEAP32[(($2002)>>2)]; + var $2004=$st; + var $2005=(($2004+2)|0); + var $2006=$2005; + var $2007=HEAP16[(($2006)>>1)]; + var $2008=(($2007)&65535); + var $2009=(($2003+($2008<<2))|0); + var $2010=$2009; + var $2011=$2010; + var $2012=(($2011)|0); + var $2013=HEAP32[(($2012)>>2)]; + var $2014=$2; + var $2015=(($2014+64)|0); + var $2016=HEAP32[(($2015)>>2)]; + var $2017=$st; + var $2018=(($2017+4)|0); + var $2019=$2018; + var $2020=HEAP16[(($2019)>>1)]; + var $2021=(($2020)&65535); + var $2022=(($2016+($2021<<2))|0); + var $2023=$2022; + var $2024=$2023; + var $2025=(($2024)|0); + HEAP32[(($2025)>>2)]=$2013; + var $2026=$2; + var $2027=(($2026+64)|0); + var $2028=HEAP32[(($2027)>>2)]; + var $2029=$st; + var $2030=(($2029+2)|0); + var $2031=$2030; + var $2032=HEAP16[(($2031)>>1)]; + var $2033=(($2032)&65535); + var $2034=(($2028+($2033<<2))|0); + var $2035=$2034; + var $2036=$2035; + var $2037=(($2036+4)|0); + var $2038=HEAP32[(($2037)>>2)]; + var $2039=$2; + var $2040=(($2039+64)|0); + var $2041=HEAP32[(($2040)>>2)]; + var $2042=$st; + var $2043=(($2042+4)|0); + var $2044=$2043; + var $2045=HEAP16[(($2044)>>1)]; + var $2046=(($2045)&65535); + var $2047=(($2041+($2046<<2))|0); + var $2048=$2047; + var $2049=$2048; + var $2050=(($2049+4)|0); + HEAP32[(($2050)>>2)]=$2038; + var $2051=$2; + var $2052=(($2051+64)|0); + var $2053=HEAP32[(($2052)>>2)]; + var $2054=$st; + var $2055=(($2054+2)|0); + var $2056=$2055; + var $2057=HEAP16[(($2056)>>1)]; + var $2058=(($2057)&65535); + var $2059=(($2053+($2058<<2))|0); + var $2060=$2059; + var $2061=$2060; + var $2062=(($2061+8)|0); + var $2063=HEAP32[(($2062)>>2)]; + var $2064=$2; + var $2065=(($2064+64)|0); + var $2066=HEAP32[(($2065)>>2)]; + var $2067=$st; + var $2068=(($2067+4)|0); + var $2069=$2068; + var $2070=HEAP16[(($2069)>>1)]; + var $2071=(($2070)&65535); + var $2072=(($2066+($2071<<2))|0); + var $2073=$2072; + var $2074=$2073; + var $2075=(($2074+8)|0); + HEAP32[(($2075)>>2)]=$2063; + __label__ = 124; break; + case 63: + var $2077=$2; + var $2078=(($2077+64)|0); + var $2079=HEAP32[(($2078)>>2)]; + var $2080=$st; + var $2081=(($2080+4)|0); + var $2082=$2081; + var $2083=HEAP16[(($2082)>>1)]; + var $2084=(($2083)&65535); + var $2085=(($2079+($2084<<2))|0); + var $2086=$2085; + var $2087=$2086; + var $2088=HEAP32[(($2087)>>2)]; + var $2089=(($2088)|0) < 0; + if ($2089) { __label__ = 65; break; } else { __label__ = 64; break; } + case 64: + var $2091=$2; + var $2092=(($2091+64)|0); + var $2093=HEAP32[(($2092)>>2)]; + var $2094=$st; + var $2095=(($2094+4)|0); + var $2096=$2095; + var $2097=HEAP16[(($2096)>>1)]; + var $2098=(($2097)&65535); + var $2099=(($2093+($2098<<2))|0); + var $2100=$2099; + var $2101=$2100; + var $2102=HEAP32[(($2101)>>2)]; + var $2103=$2; + var $2104=(($2103+80)|0); + var $2105=HEAP32[(($2104)>>2)]; + var $2106=(($2102)>>>0) >= (($2105)>>>0); + if ($2106) { __label__ = 65; break; } else { __label__ = 66; break; } + case 65: + var $2108=$2; + var $2109=$2; + var $2110=(($2109)|0); + var $2111=HEAP32[(($2110)>>2)]; + var $2112=$2; + var $2113=(($2112+64)|0); + var $2114=HEAP32[(($2113)>>2)]; + var $2115=$st; + var $2116=(($2115+4)|0); + var $2117=$2116; + var $2118=HEAP16[(($2117)>>1)]; + var $2119=(($2118)&65535); + var $2120=(($2114+($2119<<2))|0); + var $2121=$2120; + var $2122=$2121; + var $2123=HEAP32[(($2122)>>2)]; + _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)); + __label__ = 488; break; + case 66: + var $2125=$2; + var $2126=(($2125+64)|0); + var $2127=HEAP32[(($2126)>>2)]; + var $2128=$st; + var $2129=(($2128+4)|0); + var $2130=$2129; + var $2131=HEAP16[(($2130)>>1)]; + var $2132=(($2131)&65535); + var $2133=(($2127+($2132<<2))|0); + var $2134=$2133; + var $2135=$2134; + var $2136=HEAP32[(($2135)>>2)]; + var $2137=$2; + var $2138=(($2137+144)|0); + var $2139=HEAP32[(($2138)>>2)]; + var $2140=(($2136)>>>0) < (($2139)>>>0); + if ($2140) { __label__ = 67; break; } else { __label__ = 69; break; } + case 67: + var $2142=$2; + var $2143=(($2142+148)|0); + var $2144=HEAP8[($2143)]; + var $2145=(($2144) & 1); + if ($2145) { __label__ = 69; break; } else { __label__ = 68; break; } + case 68: + var $2147=$2; + var $2148=$2; + var $2149=(($2148)|0); + var $2150=HEAP32[(($2149)>>2)]; + var $2151=$2; + var $2152=$2; + var $2153=$2; + var $2154=(($2153+64)|0); + var $2155=HEAP32[(($2154)>>2)]; + var $2156=$st; + var $2157=(($2156+4)|0); + var $2158=$2157; + var $2159=HEAP16[(($2158)>>1)]; + var $2160=(($2159)&65535); + var $2161=(($2155+($2160<<2))|0); + var $2162=$2161; + var $2163=$2162; + var $2164=HEAP32[(($2163)>>2)]; + var $2165=_prog_entfield($2152, $2164); + var $2166=(($2165+4)|0); + var $2167=HEAP32[(($2166)>>2)]; + var $2168=_prog_getstring($2151, $2167); + var $2169=$2; + var $2170=(($2169+64)|0); + var $2171=HEAP32[(($2170)>>2)]; + var $2172=$st; + var $2173=(($2172+4)|0); + var $2174=$2173; + var $2175=HEAP16[(($2174)>>1)]; + var $2176=(($2175)&65535); + var $2177=(($2171+($2176<<2))|0); + var $2178=$2177; + var $2179=$2178; + var $2180=HEAP32[(($2179)>>2)]; + _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)); + __label__ = 69; break; + case 69: + var $2182=$2; + var $2183=(($2182+76)|0); + var $2184=HEAP32[(($2183)>>2)]; + var $2185=$2; + var $2186=(($2185+64)|0); + var $2187=HEAP32[(($2186)>>2)]; + var $2188=$st; + var $2189=(($2188+4)|0); + var $2190=$2189; + var $2191=HEAP16[(($2190)>>1)]; + var $2192=(($2191)&65535); + var $2193=(($2187+($2192<<2))|0); + var $2194=$2193; + var $2195=$2194; + var $2196=HEAP32[(($2195)>>2)]; + var $2197=(($2184+($2196<<2))|0); + var $2198=$2197; + $ptr=$2198; + var $2199=$2; + var $2200=(($2199+64)|0); + var $2201=HEAP32[(($2200)>>2)]; + var $2202=$st; + var $2203=(($2202+2)|0); + var $2204=$2203; + var $2205=HEAP16[(($2204)>>1)]; + var $2206=(($2205)&65535); + var $2207=(($2201+($2206<<2))|0); + var $2208=$2207; + var $2209=$2208; + var $2210=HEAP32[(($2209)>>2)]; + var $2211=$ptr; + var $2212=$2211; + HEAP32[(($2212)>>2)]=$2210; + __label__ = 124; break; + case 70: + var $2214=$2; + var $2215=(($2214+64)|0); + var $2216=HEAP32[(($2215)>>2)]; + var $2217=$st; + var $2218=(($2217+4)|0); + var $2219=$2218; + var $2220=HEAP16[(($2219)>>1)]; + var $2221=(($2220)&65535); + var $2222=(($2216+($2221<<2))|0); + var $2223=$2222; + var $2224=$2223; + var $2225=HEAP32[(($2224)>>2)]; + var $2226=(($2225)|0) < 0; + if ($2226) { __label__ = 72; break; } else { __label__ = 71; break; } + case 71: + var $2228=$2; + var $2229=(($2228+64)|0); + var $2230=HEAP32[(($2229)>>2)]; + var $2231=$st; + var $2232=(($2231+4)|0); + var $2233=$2232; + var $2234=HEAP16[(($2233)>>1)]; + var $2235=(($2234)&65535); + var $2236=(($2230+($2235<<2))|0); + var $2237=$2236; + var $2238=$2237; + var $2239=HEAP32[(($2238)>>2)]; + var $2240=((($2239)+(2))|0); + var $2241=$2; + var $2242=(($2241+80)|0); + var $2243=HEAP32[(($2242)>>2)]; + var $2244=(($2240)>>>0) >= (($2243)>>>0); + if ($2244) { __label__ = 72; break; } else { __label__ = 73; break; } + case 72: + var $2246=$2; + var $2247=$2; + var $2248=(($2247)|0); + var $2249=HEAP32[(($2248)>>2)]; + var $2250=$2; + var $2251=(($2250+64)|0); + var $2252=HEAP32[(($2251)>>2)]; + var $2253=$st; + var $2254=(($2253+4)|0); + var $2255=$2254; + var $2256=HEAP16[(($2255)>>1)]; + var $2257=(($2256)&65535); + var $2258=(($2252+($2257<<2))|0); + var $2259=$2258; + var $2260=$2259; + var $2261=HEAP32[(($2260)>>2)]; + _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)); + __label__ = 488; break; + case 73: + var $2263=$2; + var $2264=(($2263+64)|0); + var $2265=HEAP32[(($2264)>>2)]; + var $2266=$st; + var $2267=(($2266+4)|0); + var $2268=$2267; + var $2269=HEAP16[(($2268)>>1)]; + var $2270=(($2269)&65535); + var $2271=(($2265+($2270<<2))|0); + var $2272=$2271; + var $2273=$2272; + var $2274=HEAP32[(($2273)>>2)]; + var $2275=$2; + var $2276=(($2275+144)|0); + var $2277=HEAP32[(($2276)>>2)]; + var $2278=(($2274)>>>0) < (($2277)>>>0); + if ($2278) { __label__ = 74; break; } else { __label__ = 76; break; } + case 74: + var $2280=$2; + var $2281=(($2280+148)|0); + var $2282=HEAP8[($2281)]; + var $2283=(($2282) & 1); + if ($2283) { __label__ = 76; break; } else { __label__ = 75; break; } + case 75: + var $2285=$2; + var $2286=$2; + var $2287=(($2286)|0); + var $2288=HEAP32[(($2287)>>2)]; + var $2289=$2; + var $2290=$2; + var $2291=$2; + var $2292=(($2291+64)|0); + var $2293=HEAP32[(($2292)>>2)]; + var $2294=$st; + var $2295=(($2294+4)|0); + var $2296=$2295; + var $2297=HEAP16[(($2296)>>1)]; + var $2298=(($2297)&65535); + var $2299=(($2293+($2298<<2))|0); + var $2300=$2299; + var $2301=$2300; + var $2302=HEAP32[(($2301)>>2)]; + var $2303=_prog_entfield($2290, $2302); + var $2304=(($2303+4)|0); + var $2305=HEAP32[(($2304)>>2)]; + var $2306=_prog_getstring($2289, $2305); + var $2307=$2; + var $2308=(($2307+64)|0); + var $2309=HEAP32[(($2308)>>2)]; + var $2310=$st; + var $2311=(($2310+4)|0); + var $2312=$2311; + var $2313=HEAP16[(($2312)>>1)]; + var $2314=(($2313)&65535); + var $2315=(($2309+($2314<<2))|0); + var $2316=$2315; + var $2317=$2316; + var $2318=HEAP32[(($2317)>>2)]; + _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)); + __label__ = 76; break; + case 76: + var $2320=$2; + var $2321=(($2320+76)|0); + var $2322=HEAP32[(($2321)>>2)]; + var $2323=$2; + var $2324=(($2323+64)|0); + var $2325=HEAP32[(($2324)>>2)]; + var $2326=$st; + var $2327=(($2326+4)|0); + var $2328=$2327; + var $2329=HEAP16[(($2328)>>1)]; + var $2330=(($2329)&65535); + var $2331=(($2325+($2330<<2))|0); + var $2332=$2331; + var $2333=$2332; + var $2334=HEAP32[(($2333)>>2)]; + var $2335=(($2322+($2334<<2))|0); + var $2336=$2335; + $ptr=$2336; + var $2337=$2; + var $2338=(($2337+64)|0); + var $2339=HEAP32[(($2338)>>2)]; + var $2340=$st; + var $2341=(($2340+2)|0); + var $2342=$2341; + var $2343=HEAP16[(($2342)>>1)]; + var $2344=(($2343)&65535); + var $2345=(($2339+($2344<<2))|0); + var $2346=$2345; + var $2347=$2346; + var $2348=(($2347)|0); + var $2349=HEAP32[(($2348)>>2)]; + var $2350=$ptr; + var $2351=$2350; + var $2352=(($2351)|0); + HEAP32[(($2352)>>2)]=$2349; + var $2353=$2; + var $2354=(($2353+64)|0); + var $2355=HEAP32[(($2354)>>2)]; + var $2356=$st; + var $2357=(($2356+2)|0); + var $2358=$2357; + var $2359=HEAP16[(($2358)>>1)]; + var $2360=(($2359)&65535); + var $2361=(($2355+($2360<<2))|0); + var $2362=$2361; + var $2363=$2362; + var $2364=(($2363+4)|0); + var $2365=HEAP32[(($2364)>>2)]; + var $2366=$ptr; + var $2367=$2366; + var $2368=(($2367+4)|0); + HEAP32[(($2368)>>2)]=$2365; + var $2369=$2; + var $2370=(($2369+64)|0); + var $2371=HEAP32[(($2370)>>2)]; + var $2372=$st; + var $2373=(($2372+2)|0); + var $2374=$2373; + var $2375=HEAP16[(($2374)>>1)]; + var $2376=(($2375)&65535); + var $2377=(($2371+($2376<<2))|0); + var $2378=$2377; + var $2379=$2378; + var $2380=(($2379+8)|0); + var $2381=HEAP32[(($2380)>>2)]; + var $2382=$ptr; + var $2383=$2382; + var $2384=(($2383+8)|0); + HEAP32[(($2384)>>2)]=$2381; + __label__ = 124; break; + case 77: + var $2386=$2; + var $2387=(($2386+64)|0); + var $2388=HEAP32[(($2387)>>2)]; + var $2389=$st; + var $2390=(($2389+2)|0); + var $2391=$2390; + var $2392=HEAP16[(($2391)>>1)]; + var $2393=(($2392)&65535); + var $2394=(($2388+($2393<<2))|0); + var $2395=$2394; + var $2396=$2395; + var $2397=HEAP32[(($2396)>>2)]; + var $2398=$2397 & 2147483647; + var $2399=(($2398)|0)!=0; + var $2400=$2399 ^ 1; + var $2401=(($2400)&1); + var $2402=(($2401)|0); + var $2403=$2; + var $2404=(($2403+64)|0); + var $2405=HEAP32[(($2404)>>2)]; + var $2406=$st; + var $2407=(($2406+6)|0); + var $2408=$2407; + var $2409=HEAP16[(($2408)>>1)]; + var $2410=(($2409)&65535); + var $2411=(($2405+($2410<<2))|0); + var $2412=$2411; + var $2413=$2412; + HEAPF32[(($2413)>>2)]=$2402; + __label__ = 124; break; + case 78: + var $2415=$2; + var $2416=(($2415+64)|0); + var $2417=HEAP32[(($2416)>>2)]; + var $2418=$st; + var $2419=(($2418+2)|0); + var $2420=$2419; + var $2421=HEAP16[(($2420)>>1)]; + var $2422=(($2421)&65535); + var $2423=(($2417+($2422<<2))|0); + var $2424=$2423; + var $2425=$2424; + var $2426=(($2425)|0); + var $2427=HEAPF32[(($2426)>>2)]; + var $2428=$2427 != 0; + if ($2428) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 79; break; } + case 79: + var $2430=$2; + var $2431=(($2430+64)|0); + var $2432=HEAP32[(($2431)>>2)]; + var $2433=$st; + var $2434=(($2433+2)|0); + var $2435=$2434; + var $2436=HEAP16[(($2435)>>1)]; + var $2437=(($2436)&65535); + var $2438=(($2432+($2437<<2))|0); + var $2439=$2438; + var $2440=$2439; + var $2441=(($2440+4)|0); + var $2442=HEAPF32[(($2441)>>2)]; + var $2443=$2442 != 0; + if ($2443) { var $2461 = 0;__label__ = 81; break; } else { __label__ = 80; break; } + case 80: + var $2445=$2; + var $2446=(($2445+64)|0); + var $2447=HEAP32[(($2446)>>2)]; + var $2448=$st; + var $2449=(($2448+2)|0); + var $2450=$2449; + var $2451=HEAP16[(($2450)>>1)]; + var $2452=(($2451)&65535); + var $2453=(($2447+($2452<<2))|0); + var $2454=$2453; + var $2455=$2454; + var $2456=(($2455+8)|0); + var $2457=HEAPF32[(($2456)>>2)]; + var $2458=$2457 != 0; + var $2459=$2458 ^ 1; + var $2461 = $2459;__label__ = 81; break; + case 81: + var $2461; + var $2462=(($2461)&1); + var $2463=(($2462)|0); + var $2464=$2; + var $2465=(($2464+64)|0); + var $2466=HEAP32[(($2465)>>2)]; + var $2467=$st; + var $2468=(($2467+6)|0); + var $2469=$2468; + var $2470=HEAP16[(($2469)>>1)]; + var $2471=(($2470)&65535); + var $2472=(($2466+($2471<<2))|0); + var $2473=$2472; + var $2474=$2473; + HEAPF32[(($2474)>>2)]=$2463; + __label__ = 124; break; + case 82: + var $2476=$2; + var $2477=(($2476+64)|0); + var $2478=HEAP32[(($2477)>>2)]; + var $2479=$st; + var $2480=(($2479+2)|0); + var $2481=$2480; + var $2482=HEAP16[(($2481)>>1)]; + var $2483=(($2482)&65535); + var $2484=(($2478+($2483<<2))|0); + var $2485=$2484; + var $2486=$2485; + var $2487=HEAP32[(($2486)>>2)]; + var $2488=(($2487)|0)!=0; + if ($2488) { __label__ = 83; break; } else { var $2508 = 1;__label__ = 84; break; } + case 83: + var $2490=$2; + var $2491=$2; + var $2492=(($2491+64)|0); + var $2493=HEAP32[(($2492)>>2)]; + var $2494=$st; + var $2495=(($2494+2)|0); + var $2496=$2495; + var $2497=HEAP16[(($2496)>>1)]; + var $2498=(($2497)&65535); + var $2499=(($2493+($2498<<2))|0); + var $2500=$2499; + var $2501=$2500; + var $2502=HEAP32[(($2501)>>2)]; + var $2503=_prog_getstring($2490, $2502); + var $2504=HEAP8[($2503)]; + var $2505=(($2504 << 24) >> 24)!=0; + var $2506=$2505 ^ 1; + var $2508 = $2506;__label__ = 84; break; + case 84: + var $2508; + var $2509=(($2508)&1); + var $2510=(($2509)|0); + var $2511=$2; + var $2512=(($2511+64)|0); + var $2513=HEAP32[(($2512)>>2)]; + var $2514=$st; + var $2515=(($2514+6)|0); + var $2516=$2515; + var $2517=HEAP16[(($2516)>>1)]; + var $2518=(($2517)&65535); + var $2519=(($2513+($2518<<2))|0); + var $2520=$2519; + var $2521=$2520; + HEAPF32[(($2521)>>2)]=$2510; + __label__ = 124; break; + case 85: + var $2523=$2; + var $2524=(($2523+64)|0); + var $2525=HEAP32[(($2524)>>2)]; + var $2526=$st; + var $2527=(($2526+2)|0); + var $2528=$2527; + var $2529=HEAP16[(($2528)>>1)]; + var $2530=(($2529)&65535); + var $2531=(($2525+($2530<<2))|0); + var $2532=$2531; + var $2533=$2532; + var $2534=HEAP32[(($2533)>>2)]; + var $2535=(($2534)|0)==0; + var $2536=(($2535)&1); + var $2537=(($2536)|0); + var $2538=$2; + var $2539=(($2538+64)|0); + var $2540=HEAP32[(($2539)>>2)]; + var $2541=$st; + var $2542=(($2541+6)|0); + var $2543=$2542; + var $2544=HEAP16[(($2543)>>1)]; + var $2545=(($2544)&65535); + var $2546=(($2540+($2545<<2))|0); + var $2547=$2546; + var $2548=$2547; + HEAPF32[(($2548)>>2)]=$2537; + __label__ = 124; break; + case 86: + var $2550=$2; + var $2551=(($2550+64)|0); + var $2552=HEAP32[(($2551)>>2)]; + var $2553=$st; + var $2554=(($2553+2)|0); + var $2555=$2554; + var $2556=HEAP16[(($2555)>>1)]; + var $2557=(($2556)&65535); + var $2558=(($2552+($2557<<2))|0); + var $2559=$2558; + var $2560=$2559; + var $2561=HEAP32[(($2560)>>2)]; + var $2562=(($2561)|0)!=0; + var $2563=$2562 ^ 1; + var $2564=(($2563)&1); + var $2565=(($2564)|0); + var $2566=$2; + var $2567=(($2566+64)|0); + var $2568=HEAP32[(($2567)>>2)]; + var $2569=$st; + var $2570=(($2569+6)|0); + var $2571=$2570; + var $2572=HEAP16[(($2571)>>1)]; + var $2573=(($2572)&65535); + var $2574=(($2568+($2573<<2))|0); + var $2575=$2574; + var $2576=$2575; + HEAPF32[(($2576)>>2)]=$2565; + __label__ = 124; break; + case 87: + var $2578=$2; + var $2579=(($2578+64)|0); + var $2580=HEAP32[(($2579)>>2)]; + var $2581=$st; + var $2582=(($2581+2)|0); + var $2583=$2582; + var $2584=HEAP16[(($2583)>>1)]; + var $2585=(($2584)&65535); + var $2586=(($2580+($2585<<2))|0); + var $2587=$2586; + var $2588=$2587; + var $2589=HEAP32[(($2588)>>2)]; + var $2590=$2589 & 2147483647; + var $2591=(($2590)|0)!=0; + if ($2591) { __label__ = 88; break; } else { __label__ = 91; break; } + case 88: + var $2593=$st; + var $2594=(($2593+4)|0); + var $2595=$2594; + var $2596=HEAP16[(($2595)>>1)]; + var $2597=(($2596 << 16) >> 16); + var $2598=((($2597)-(1))|0); + var $2599=$st; + var $2600=(($2599+($2598<<3))|0); + $st=$2600; + var $2601=$jumpcount; + var $2602=((($2601)+(1))|0); + $jumpcount=$2602; + var $2603=$5; + var $2604=(($2602)|0) >= (($2603)|0); + if ($2604) { __label__ = 89; break; } else { __label__ = 90; break; } + case 89: + var $2606=$2; + var $2607=$2; + var $2608=(($2607)|0); + var $2609=HEAP32[(($2608)>>2)]; + var $2610=$jumpcount; + _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)); + __label__ = 90; break; + case 90: + __label__ = 91; break; + case 91: + __label__ = 124; break; + case 92: + var $2614=$2; + var $2615=(($2614+64)|0); + var $2616=HEAP32[(($2615)>>2)]; + var $2617=$st; + var $2618=(($2617+2)|0); + var $2619=$2618; + var $2620=HEAP16[(($2619)>>1)]; + var $2621=(($2620)&65535); + var $2622=(($2616+($2621<<2))|0); + var $2623=$2622; + var $2624=$2623; + var $2625=HEAP32[(($2624)>>2)]; + var $2626=$2625 & 2147483647; + var $2627=(($2626)|0)!=0; + if ($2627) { __label__ = 96; break; } else { __label__ = 93; break; } + case 93: + var $2629=$st; + var $2630=(($2629+4)|0); + var $2631=$2630; + var $2632=HEAP16[(($2631)>>1)]; + var $2633=(($2632 << 16) >> 16); + var $2634=((($2633)-(1))|0); + var $2635=$st; + var $2636=(($2635+($2634<<3))|0); + $st=$2636; + var $2637=$jumpcount; + var $2638=((($2637)+(1))|0); + $jumpcount=$2638; + var $2639=$5; + var $2640=(($2638)|0) >= (($2639)|0); + if ($2640) { __label__ = 94; break; } else { __label__ = 95; break; } + case 94: + var $2642=$2; + var $2643=$2; + var $2644=(($2643)|0); + var $2645=HEAP32[(($2644)>>2)]; + var $2646=$jumpcount; + _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)); + __label__ = 95; break; + case 95: + __label__ = 96; break; + case 96: + __label__ = 124; break; + case 97: + var $2650=$st; + var $2651=(($2650)|0); + var $2652=HEAP16[(($2651)>>1)]; + var $2653=(($2652)&65535); + var $2654=((($2653)-(51))|0); + var $2655=$2; + var $2656=(($2655+184)|0); + HEAP32[(($2656)>>2)]=$2654; + var $2657=$2; + var $2658=(($2657+64)|0); + var $2659=HEAP32[(($2658)>>2)]; + var $2660=$st; + var $2661=(($2660+2)|0); + var $2662=$2661; + var $2663=HEAP16[(($2662)>>1)]; + var $2664=(($2663)&65535); + var $2665=(($2659+($2664<<2))|0); + var $2666=$2665; + var $2667=$2666; + var $2668=HEAP32[(($2667)>>2)]; + var $2669=(($2668)|0)!=0; + if ($2669) { __label__ = 99; break; } else { __label__ = 98; break; } + case 98: + var $2671=$2; + var $2672=$2; + var $2673=(($2672)|0); + var $2674=HEAP32[(($2673)>>2)]; + _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)); + __label__ = 99; break; + case 99: + var $2676=$2; + var $2677=(($2676+64)|0); + var $2678=HEAP32[(($2677)>>2)]; + var $2679=$st; + var $2680=(($2679+2)|0); + var $2681=$2680; + var $2682=HEAP16[(($2681)>>1)]; + var $2683=(($2682)&65535); + var $2684=(($2678+($2683<<2))|0); + var $2685=$2684; + var $2686=$2685; + var $2687=HEAP32[(($2686)>>2)]; + var $2688=(($2687)|0)!=0; + if ($2688) { __label__ = 100; break; } else { __label__ = 101; break; } + case 100: + var $2690=$2; + var $2691=(($2690+64)|0); + var $2692=HEAP32[(($2691)>>2)]; + var $2693=$st; + var $2694=(($2693+2)|0); + var $2695=$2694; + var $2696=HEAP16[(($2695)>>1)]; + var $2697=(($2696)&65535); + var $2698=(($2692+($2697<<2))|0); + var $2699=$2698; + var $2700=$2699; + var $2701=HEAP32[(($2700)>>2)]; + var $2702=$2; + var $2703=(($2702+44)|0); + var $2704=HEAP32[(($2703)>>2)]; + var $2705=(($2701)>>>0) >= (($2704)>>>0); + if ($2705) { __label__ = 101; break; } else { __label__ = 102; break; } + case 101: + var $2707=$2; + var $2708=$2; + var $2709=(($2708)|0); + var $2710=HEAP32[(($2709)>>2)]; + _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)); + __label__ = 488; break; + case 102: + var $2712=$2; + var $2713=(($2712+64)|0); + var $2714=HEAP32[(($2713)>>2)]; + var $2715=$st; + var $2716=(($2715+2)|0); + var $2717=$2716; + var $2718=HEAP16[(($2717)>>1)]; + var $2719=(($2718)&65535); + var $2720=(($2714+($2719<<2))|0); + var $2721=$2720; + var $2722=$2721; + var $2723=HEAP32[(($2722)>>2)]; + var $2724=$2; + var $2725=(($2724+40)|0); + var $2726=HEAP32[(($2725)>>2)]; + var $2727=(($2726+($2723)*(36))|0); + $newf=$2727; + var $2728=$newf; + var $2729=(($2728+12)|0); + var $2730=HEAP32[(($2729)>>2)]; + var $2731=((($2730)+(1))|0); + HEAP32[(($2729)>>2)]=$2731; + var $2732=$st; + var $2733=$2; + var $2734=(($2733+4)|0); + var $2735=HEAP32[(($2734)>>2)]; + var $2736=$2732; + var $2737=$2735; + var $2738=((($2736)-($2737))|0); + var $2739=((((($2738)|0))/(8))&-1); + var $2740=((($2739)+(1))|0); + var $2741=$2; + var $2742=(($2741+176)|0); + HEAP32[(($2742)>>2)]=$2740; + var $2743=$newf; + var $2744=(($2743)|0); + var $2745=HEAP32[(($2744)>>2)]; + var $2746=(($2745)|0) < 0; + if ($2746) { __label__ = 103; break; } else { __label__ = 108; break; } + case 103: + var $2748=$newf; + var $2749=(($2748)|0); + var $2750=HEAP32[(($2749)>>2)]; + var $2751=(((-$2750))|0); + $builtinnumber=$2751; + var $2752=$builtinnumber; + var $2753=$2; + var $2754=(($2753+132)|0); + var $2755=HEAP32[(($2754)>>2)]; + var $2756=(($2752)>>>0) < (($2755)>>>0); + if ($2756) { __label__ = 104; break; } else { __label__ = 106; break; } + case 104: + var $2758=$builtinnumber; + var $2759=$2; + var $2760=(($2759+128)|0); + var $2761=HEAP32[(($2760)>>2)]; + var $2762=(($2761+($2758<<2))|0); + var $2763=HEAP32[(($2762)>>2)]; + var $2764=(($2763)|0)!=0; + if ($2764) { __label__ = 105; break; } else { __label__ = 106; break; } + case 105: + var $2766=$builtinnumber; + var $2767=$2; + var $2768=(($2767+128)|0); + var $2769=HEAP32[(($2768)>>2)]; + var $2770=(($2769+($2766<<2))|0); + var $2771=HEAP32[(($2770)>>2)]; + var $2772=$2; + var $2773=FUNCTION_TABLE[$2771]($2772); + __label__ = 107; break; + case 106: + var $2775=$2; + var $2776=$builtinnumber; + var $2777=$2; + var $2778=(($2777)|0); + var $2779=HEAP32[(($2778)>>2)]; + _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)); + __label__ = 107; break; + case 107: + __label__ = 109; break; + case 108: + var $2782=$2; + var $2783=(($2782+4)|0); + var $2784=HEAP32[(($2783)>>2)]; + var $2785=$2; + var $2786=$newf; + var $2787=_prog_enterfunction($2785, $2786); + var $2788=(($2784+($2787<<3))|0); + var $2789=((($2788)-(8))|0); + $st=$2789; + __label__ = 109; break; + case 109: + var $2791=$2; + var $2792=(($2791+112)|0); + var $2793=HEAP32[(($2792)>>2)]; + var $2794=(($2793)|0)!=0; + if ($2794) { __label__ = 110; break; } else { __label__ = 111; break; } + case 110: + __label__ = 488; break; + case 111: + __label__ = 124; break; + case 112: + var $2798=$2; + var $2799=$2; + var $2800=(($2799)|0); + var $2801=HEAP32[(($2800)>>2)]; + _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)); + __label__ = 124; break; + case 113: + var $2803=$st; + var $2804=(($2803+2)|0); + var $2805=$2804; + var $2806=HEAP16[(($2805)>>1)]; + var $2807=(($2806 << 16) >> 16); + var $2808=((($2807)-(1))|0); + var $2809=$st; + var $2810=(($2809+($2808<<3))|0); + $st=$2810; + var $2811=$jumpcount; + var $2812=((($2811)+(1))|0); + $jumpcount=$2812; + var $2813=(($2812)|0)==10000000; + if ($2813) { __label__ = 114; break; } else { __label__ = 115; break; } + case 114: + var $2815=$2; + var $2816=$2; + var $2817=(($2816)|0); + var $2818=HEAP32[(($2817)>>2)]; + var $2819=$jumpcount; + _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)); + __label__ = 115; break; + case 115: + __label__ = 124; break; + case 116: + var $2822=$2; + var $2823=(($2822+64)|0); + var $2824=HEAP32[(($2823)>>2)]; + var $2825=$st; + var $2826=(($2825+2)|0); + var $2827=$2826; + var $2828=HEAP16[(($2827)>>1)]; + var $2829=(($2828)&65535); + var $2830=(($2824+($2829<<2))|0); + var $2831=$2830; + var $2832=$2831; + var $2833=HEAP32[(($2832)>>2)]; + var $2834=$2833 & 2147483647; + var $2835=(($2834)|0)!=0; + if ($2835) { __label__ = 117; break; } else { var $2852 = 0;__label__ = 118; break; } + case 117: + var $2837=$2; + var $2838=(($2837+64)|0); + var $2839=HEAP32[(($2838)>>2)]; + var $2840=$st; + var $2841=(($2840+4)|0); + var $2842=$2841; + var $2843=HEAP16[(($2842)>>1)]; + var $2844=(($2843)&65535); + var $2845=(($2839+($2844<<2))|0); + var $2846=$2845; + var $2847=$2846; + var $2848=HEAP32[(($2847)>>2)]; + var $2849=$2848 & 2147483647; + var $2850=(($2849)|0)!=0; + var $2852 = $2850;__label__ = 118; break; + case 118: + var $2852; + var $2853=(($2852)&1); + var $2854=(($2853)|0); + var $2855=$2; + var $2856=(($2855+64)|0); + var $2857=HEAP32[(($2856)>>2)]; + var $2858=$st; + var $2859=(($2858+6)|0); + var $2860=$2859; + var $2861=HEAP16[(($2860)>>1)]; + var $2862=(($2861)&65535); + var $2863=(($2857+($2862<<2))|0); + var $2864=$2863; + var $2865=$2864; + HEAPF32[(($2865)>>2)]=$2854; + __label__ = 124; break; + case 119: + var $2867=$2; + var $2868=(($2867+64)|0); + var $2869=HEAP32[(($2868)>>2)]; + var $2870=$st; + var $2871=(($2870+2)|0); + var $2872=$2871; + var $2873=HEAP16[(($2872)>>1)]; + var $2874=(($2873)&65535); + var $2875=(($2869+($2874<<2))|0); + var $2876=$2875; + var $2877=$2876; + var $2878=HEAP32[(($2877)>>2)]; + var $2879=$2878 & 2147483647; + var $2880=(($2879)|0)!=0; + if ($2880) { var $2897 = 1;__label__ = 121; break; } else { __label__ = 120; break; } + case 120: + var $2882=$2; + var $2883=(($2882+64)|0); + var $2884=HEAP32[(($2883)>>2)]; + var $2885=$st; + var $2886=(($2885+4)|0); + var $2887=$2886; + var $2888=HEAP16[(($2887)>>1)]; + var $2889=(($2888)&65535); + var $2890=(($2884+($2889<<2))|0); + var $2891=$2890; + var $2892=$2891; + var $2893=HEAP32[(($2892)>>2)]; + var $2894=$2893 & 2147483647; + var $2895=(($2894)|0)!=0; + var $2897 = $2895;__label__ = 121; break; + case 121: + var $2897; + var $2898=(($2897)&1); + var $2899=(($2898)|0); + var $2900=$2; + var $2901=(($2900+64)|0); + var $2902=HEAP32[(($2901)>>2)]; + var $2903=$st; + var $2904=(($2903+6)|0); + var $2905=$2904; + var $2906=HEAP16[(($2905)>>1)]; + var $2907=(($2906)&65535); + var $2908=(($2902+($2907<<2))|0); + var $2909=$2908; + var $2910=$2909; + HEAPF32[(($2910)>>2)]=$2899; + __label__ = 124; break; + case 122: + var $2912=$2; + var $2913=(($2912+64)|0); + var $2914=HEAP32[(($2913)>>2)]; + var $2915=$st; + var $2916=(($2915+2)|0); + var $2917=$2916; + var $2918=HEAP16[(($2917)>>1)]; + var $2919=(($2918)&65535); + var $2920=(($2914+($2919<<2))|0); + var $2921=$2920; + var $2922=$2921; + var $2923=HEAPF32[(($2922)>>2)]; + var $2924=(($2923)&-1); + var $2925=$2; + var $2926=(($2925+64)|0); + var $2927=HEAP32[(($2926)>>2)]; + var $2928=$st; + var $2929=(($2928+4)|0); + var $2930=$2929; + var $2931=HEAP16[(($2930)>>1)]; + var $2932=(($2931)&65535); + var $2933=(($2927+($2932<<2))|0); + var $2934=$2933; + var $2935=$2934; + var $2936=HEAPF32[(($2935)>>2)]; + var $2937=(($2936)&-1); + var $2938=$2924 & $2937; + var $2939=(($2938)|0); + var $2940=$2; + var $2941=(($2940+64)|0); + var $2942=HEAP32[(($2941)>>2)]; + var $2943=$st; + var $2944=(($2943+6)|0); + var $2945=$2944; + var $2946=HEAP16[(($2945)>>1)]; + var $2947=(($2946)&65535); + var $2948=(($2942+($2947<<2))|0); + var $2949=$2948; + var $2950=$2949; + HEAPF32[(($2950)>>2)]=$2939; + __label__ = 124; break; + case 123: + var $2952=$2; + var $2953=(($2952+64)|0); + var $2954=HEAP32[(($2953)>>2)]; + var $2955=$st; + var $2956=(($2955+2)|0); + var $2957=$2956; + var $2958=HEAP16[(($2957)>>1)]; + var $2959=(($2958)&65535); + var $2960=(($2954+($2959<<2))|0); + var $2961=$2960; + var $2962=$2961; + var $2963=HEAPF32[(($2962)>>2)]; + var $2964=(($2963)&-1); + var $2965=$2; + var $2966=(($2965+64)|0); + var $2967=HEAP32[(($2966)>>2)]; + var $2968=$st; + var $2969=(($2968+4)|0); + var $2970=$2969; + var $2971=HEAP16[(($2970)>>1)]; + var $2972=(($2971)&65535); + var $2973=(($2967+($2972<<2))|0); + var $2974=$2973; + var $2975=$2974; + var $2976=HEAPF32[(($2975)>>2)]; + var $2977=(($2976)&-1); + var $2978=$2964 | $2977; + var $2979=(($2978)|0); + var $2980=$2; + var $2981=(($2980+64)|0); + var $2982=HEAP32[(($2981)>>2)]; + var $2983=$st; + var $2984=(($2983+6)|0); + var $2985=$2984; + var $2986=HEAP16[(($2985)>>1)]; + var $2987=(($2986)&65535); + var $2988=(($2982+($2987<<2))|0); + var $2989=$2988; + var $2990=$2989; + HEAPF32[(($2990)>>2)]=$2979; + __label__ = 124; break; + case 124: + __label__ = 5; break; + case 125: + __label__ = 126; break; + case 126: + var $2994=$st; + var $2995=(($2994+8)|0); + $st=$2995; + var $2996=$2; + var $2997=$st; + _prog_print_statement($2996, $2997); + var $2998=$st; + var $2999=(($2998)|0); + var $3000=HEAP16[(($2999)>>1)]; + var $3001=(($3000)&65535); + if ((($3001)|0) == 0 || (($3001)|0) == 43) { + __label__ = 128; break; + } + else if ((($3001)|0) == 1) { + __label__ = 131; break; + } + else if ((($3001)|0) == 2) { + __label__ = 132; break; + } + else if ((($3001)|0) == 3) { + __label__ = 133; break; + } + else if ((($3001)|0) == 4) { + __label__ = 134; break; + } + else if ((($3001)|0) == 5) { + __label__ = 135; break; + } + else if ((($3001)|0) == 6) { + __label__ = 139; break; + } + else if ((($3001)|0) == 7) { + __label__ = 140; break; + } + else if ((($3001)|0) == 8) { + __label__ = 141; break; + } + else if ((($3001)|0) == 9) { + __label__ = 142; break; + } + else if ((($3001)|0) == 10) { + __label__ = 143; break; + } + else if ((($3001)|0) == 11) { + __label__ = 144; break; + } + else if ((($3001)|0) == 12) { + __label__ = 148; break; + } + else if ((($3001)|0) == 13) { + __label__ = 149; break; + } + else if ((($3001)|0) == 14) { + __label__ = 150; break; + } + else if ((($3001)|0) == 15) { + __label__ = 151; break; + } + else if ((($3001)|0) == 16) { + __label__ = 152; break; + } + else if ((($3001)|0) == 17) { + __label__ = 156; break; + } + else if ((($3001)|0) == 18) { + __label__ = 157; break; + } + else if ((($3001)|0) == 19) { + __label__ = 158; break; + } + else if ((($3001)|0) == 20) { + __label__ = 159; break; + } + else if ((($3001)|0) == 21) { + __label__ = 160; break; + } + else if ((($3001)|0) == 22) { + __label__ = 161; break; + } + else if ((($3001)|0) == 23) { + __label__ = 162; break; + } + else if ((($3001)|0) == 24 || (($3001)|0) == 26 || (($3001)|0) == 28 || (($3001)|0) == 27 || (($3001)|0) == 29) { + __label__ = 163; break; + } + else if ((($3001)|0) == 25) { + __label__ = 169; break; + } + else if ((($3001)|0) == 30) { + __label__ = 176; break; + } + else if ((($3001)|0) == 31 || (($3001)|0) == 33 || (($3001)|0) == 34 || (($3001)|0) == 35 || (($3001)|0) == 36) { + __label__ = 182; break; + } + else if ((($3001)|0) == 32) { + __label__ = 183; break; + } + else if ((($3001)|0) == 37 || (($3001)|0) == 39 || (($3001)|0) == 40 || (($3001)|0) == 41 || (($3001)|0) == 42) { + __label__ = 184; break; + } + else if ((($3001)|0) == 38) { + __label__ = 191; break; + } + else if ((($3001)|0) == 44) { + __label__ = 198; break; + } + else if ((($3001)|0) == 45) { + __label__ = 199; break; + } + else if ((($3001)|0) == 46) { + __label__ = 203; break; + } + else if ((($3001)|0) == 47) { + __label__ = 206; break; + } + else if ((($3001)|0) == 48) { + __label__ = 207; break; + } + else if ((($3001)|0) == 49) { + __label__ = 208; break; + } + else if ((($3001)|0) == 50) { + __label__ = 213; break; + } + 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) { + __label__ = 218; break; + } + else if ((($3001)|0) == 60) { + __label__ = 233; break; + } + else if ((($3001)|0) == 61) { + __label__ = 234; break; + } + else if ((($3001)|0) == 62) { + __label__ = 237; break; + } + else if ((($3001)|0) == 63) { + __label__ = 240; break; + } + else if ((($3001)|0) == 64) { + __label__ = 243; break; + } + else if ((($3001)|0) == 65) { + __label__ = 244; break; + } + else { + __label__ = 127; break; + } + + case 127: + var $3003=$2; + var $3004=$2; + var $3005=(($3004)|0); + var $3006=HEAP32[(($3005)>>2)]; + _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)); + __label__ = 488; break; + case 128: + var $3008=$2; + var $3009=(($3008+64)|0); + var $3010=HEAP32[(($3009)>>2)]; + var $3011=$st; + var $3012=(($3011+2)|0); + var $3013=$3012; + var $3014=HEAP16[(($3013)>>1)]; + var $3015=(($3014)&65535); + var $3016=(($3010+($3015<<2))|0); + var $3017=$3016; + var $3018=$3017; + var $3019=(($3018)|0); + var $3020=HEAP32[(($3019)>>2)]; + var $3021=$2; + var $3022=(($3021+64)|0); + var $3023=HEAP32[(($3022)>>2)]; + var $3024=(($3023+4)|0); + var $3025=$3024; + var $3026=$3025; + var $3027=(($3026)|0); + HEAP32[(($3027)>>2)]=$3020; + var $3028=$2; + var $3029=(($3028+64)|0); + var $3030=HEAP32[(($3029)>>2)]; + var $3031=$st; + var $3032=(($3031+2)|0); + var $3033=$3032; + var $3034=HEAP16[(($3033)>>1)]; + var $3035=(($3034)&65535); + var $3036=(($3030+($3035<<2))|0); + var $3037=$3036; + var $3038=$3037; + var $3039=(($3038+4)|0); + var $3040=HEAP32[(($3039)>>2)]; + var $3041=$2; + var $3042=(($3041+64)|0); + var $3043=HEAP32[(($3042)>>2)]; + var $3044=(($3043+4)|0); + var $3045=$3044; + var $3046=$3045; + var $3047=(($3046+4)|0); + HEAP32[(($3047)>>2)]=$3040; + var $3048=$2; + var $3049=(($3048+64)|0); + var $3050=HEAP32[(($3049)>>2)]; + var $3051=$st; + var $3052=(($3051+2)|0); + var $3053=$3052; + var $3054=HEAP16[(($3053)>>1)]; + var $3055=(($3054)&65535); + var $3056=(($3050+($3055<<2))|0); + var $3057=$3056; + var $3058=$3057; + var $3059=(($3058+8)|0); + var $3060=HEAP32[(($3059)>>2)]; + var $3061=$2; + var $3062=(($3061+64)|0); + var $3063=HEAP32[(($3062)>>2)]; + var $3064=(($3063+4)|0); + var $3065=$3064; + var $3066=$3065; + var $3067=(($3066+8)|0); + HEAP32[(($3067)>>2)]=$3060; + var $3068=$2; + var $3069=(($3068+4)|0); + var $3070=HEAP32[(($3069)>>2)]; + var $3071=$2; + var $3072=_prog_leavefunction($3071); + var $3073=(($3070+($3072<<3))|0); + $st=$3073; + var $3074=$2; + var $3075=(($3074+168)|0); + var $3076=HEAP32[(($3075)>>2)]; + var $3077=(($3076)|0)!=0; + if ($3077) { __label__ = 130; break; } else { __label__ = 129; break; } + case 129: + __label__ = 488; break; + case 130: + __label__ = 245; break; + case 131: + var $3081=$2; + var $3082=(($3081+64)|0); + var $3083=HEAP32[(($3082)>>2)]; + var $3084=$st; + var $3085=(($3084+2)|0); + var $3086=$3085; + var $3087=HEAP16[(($3086)>>1)]; + var $3088=(($3087)&65535); + var $3089=(($3083+($3088<<2))|0); + var $3090=$3089; + var $3091=$3090; + var $3092=HEAPF32[(($3091)>>2)]; + var $3093=$2; + var $3094=(($3093+64)|0); + var $3095=HEAP32[(($3094)>>2)]; + var $3096=$st; + var $3097=(($3096+4)|0); + var $3098=$3097; + var $3099=HEAP16[(($3098)>>1)]; + var $3100=(($3099)&65535); + var $3101=(($3095+($3100<<2))|0); + var $3102=$3101; + var $3103=$3102; + var $3104=HEAPF32[(($3103)>>2)]; + var $3105=($3092)*($3104); + var $3106=$2; + var $3107=(($3106+64)|0); + var $3108=HEAP32[(($3107)>>2)]; + var $3109=$st; + var $3110=(($3109+6)|0); + var $3111=$3110; + var $3112=HEAP16[(($3111)>>1)]; + var $3113=(($3112)&65535); + var $3114=(($3108+($3113<<2))|0); + var $3115=$3114; + var $3116=$3115; + HEAPF32[(($3116)>>2)]=$3105; + __label__ = 245; break; + case 132: + var $3118=$2; + var $3119=(($3118+64)|0); + var $3120=HEAP32[(($3119)>>2)]; + var $3121=$st; + var $3122=(($3121+2)|0); + var $3123=$3122; + var $3124=HEAP16[(($3123)>>1)]; + var $3125=(($3124)&65535); + var $3126=(($3120+($3125<<2))|0); + var $3127=$3126; + var $3128=$3127; + var $3129=(($3128)|0); + var $3130=HEAPF32[(($3129)>>2)]; + var $3131=$2; + var $3132=(($3131+64)|0); + var $3133=HEAP32[(($3132)>>2)]; + var $3134=$st; + var $3135=(($3134+4)|0); + var $3136=$3135; + var $3137=HEAP16[(($3136)>>1)]; + var $3138=(($3137)&65535); + var $3139=(($3133+($3138<<2))|0); + var $3140=$3139; + var $3141=$3140; + var $3142=(($3141)|0); + var $3143=HEAPF32[(($3142)>>2)]; + var $3144=($3130)*($3143); + var $3145=$2; + var $3146=(($3145+64)|0); + var $3147=HEAP32[(($3146)>>2)]; + var $3148=$st; + var $3149=(($3148+2)|0); + var $3150=$3149; + var $3151=HEAP16[(($3150)>>1)]; + var $3152=(($3151)&65535); + var $3153=(($3147+($3152<<2))|0); + var $3154=$3153; + var $3155=$3154; + var $3156=(($3155+4)|0); + var $3157=HEAPF32[(($3156)>>2)]; + var $3158=$2; + var $3159=(($3158+64)|0); + var $3160=HEAP32[(($3159)>>2)]; + var $3161=$st; + var $3162=(($3161+4)|0); + var $3163=$3162; + var $3164=HEAP16[(($3163)>>1)]; + var $3165=(($3164)&65535); + var $3166=(($3160+($3165<<2))|0); + var $3167=$3166; + var $3168=$3167; + var $3169=(($3168+4)|0); + var $3170=HEAPF32[(($3169)>>2)]; + var $3171=($3157)*($3170); + var $3172=($3144)+($3171); + var $3173=$2; + var $3174=(($3173+64)|0); + var $3175=HEAP32[(($3174)>>2)]; + var $3176=$st; + var $3177=(($3176+2)|0); + var $3178=$3177; + var $3179=HEAP16[(($3178)>>1)]; + var $3180=(($3179)&65535); + var $3181=(($3175+($3180<<2))|0); + var $3182=$3181; + var $3183=$3182; + var $3184=(($3183+8)|0); + var $3185=HEAPF32[(($3184)>>2)]; + var $3186=$2; + var $3187=(($3186+64)|0); + var $3188=HEAP32[(($3187)>>2)]; + var $3189=$st; + var $3190=(($3189+4)|0); + var $3191=$3190; + var $3192=HEAP16[(($3191)>>1)]; + var $3193=(($3192)&65535); + var $3194=(($3188+($3193<<2))|0); + var $3195=$3194; + var $3196=$3195; + var $3197=(($3196+8)|0); + var $3198=HEAPF32[(($3197)>>2)]; + var $3199=($3185)*($3198); + var $3200=($3172)+($3199); + var $3201=$2; + var $3202=(($3201+64)|0); + var $3203=HEAP32[(($3202)>>2)]; + var $3204=$st; + var $3205=(($3204+6)|0); + var $3206=$3205; + var $3207=HEAP16[(($3206)>>1)]; + var $3208=(($3207)&65535); + var $3209=(($3203+($3208<<2))|0); + var $3210=$3209; + var $3211=$3210; + HEAPF32[(($3211)>>2)]=$3200; + __label__ = 245; break; + case 133: + var $3213=$2; + var $3214=(($3213+64)|0); + var $3215=HEAP32[(($3214)>>2)]; + var $3216=$st; + var $3217=(($3216+2)|0); + var $3218=$3217; + var $3219=HEAP16[(($3218)>>1)]; + var $3220=(($3219)&65535); + var $3221=(($3215+($3220<<2))|0); + var $3222=$3221; + var $3223=$3222; + var $3224=HEAPF32[(($3223)>>2)]; + var $3225=$2; + var $3226=(($3225+64)|0); + var $3227=HEAP32[(($3226)>>2)]; + var $3228=$st; + var $3229=(($3228+4)|0); + var $3230=$3229; + var $3231=HEAP16[(($3230)>>1)]; + var $3232=(($3231)&65535); + var $3233=(($3227+($3232<<2))|0); + var $3234=$3233; + var $3235=$3234; + var $3236=(($3235)|0); + var $3237=HEAPF32[(($3236)>>2)]; + var $3238=($3224)*($3237); + var $3239=$2; + var $3240=(($3239+64)|0); + var $3241=HEAP32[(($3240)>>2)]; + var $3242=$st; + var $3243=(($3242+6)|0); + var $3244=$3243; + var $3245=HEAP16[(($3244)>>1)]; + var $3246=(($3245)&65535); + var $3247=(($3241+($3246<<2))|0); + var $3248=$3247; + var $3249=$3248; + var $3250=(($3249)|0); + HEAPF32[(($3250)>>2)]=$3238; + var $3251=$2; + var $3252=(($3251+64)|0); + var $3253=HEAP32[(($3252)>>2)]; + var $3254=$st; + var $3255=(($3254+2)|0); + var $3256=$3255; + var $3257=HEAP16[(($3256)>>1)]; + var $3258=(($3257)&65535); + var $3259=(($3253+($3258<<2))|0); + var $3260=$3259; + var $3261=$3260; + var $3262=HEAPF32[(($3261)>>2)]; + var $3263=$2; + var $3264=(($3263+64)|0); + var $3265=HEAP32[(($3264)>>2)]; + var $3266=$st; + var $3267=(($3266+4)|0); + var $3268=$3267; + var $3269=HEAP16[(($3268)>>1)]; + var $3270=(($3269)&65535); + var $3271=(($3265+($3270<<2))|0); + var $3272=$3271; + var $3273=$3272; + var $3274=(($3273+4)|0); + var $3275=HEAPF32[(($3274)>>2)]; + var $3276=($3262)*($3275); + var $3277=$2; + var $3278=(($3277+64)|0); + var $3279=HEAP32[(($3278)>>2)]; + var $3280=$st; + var $3281=(($3280+6)|0); + var $3282=$3281; + var $3283=HEAP16[(($3282)>>1)]; + var $3284=(($3283)&65535); + var $3285=(($3279+($3284<<2))|0); + var $3286=$3285; + var $3287=$3286; + var $3288=(($3287+4)|0); + HEAPF32[(($3288)>>2)]=$3276; + var $3289=$2; + var $3290=(($3289+64)|0); + var $3291=HEAP32[(($3290)>>2)]; + var $3292=$st; + var $3293=(($3292+2)|0); + var $3294=$3293; + var $3295=HEAP16[(($3294)>>1)]; + var $3296=(($3295)&65535); + var $3297=(($3291+($3296<<2))|0); + var $3298=$3297; + var $3299=$3298; + var $3300=HEAPF32[(($3299)>>2)]; + var $3301=$2; + var $3302=(($3301+64)|0); + var $3303=HEAP32[(($3302)>>2)]; + var $3304=$st; + var $3305=(($3304+4)|0); + var $3306=$3305; + var $3307=HEAP16[(($3306)>>1)]; + var $3308=(($3307)&65535); + var $3309=(($3303+($3308<<2))|0); + var $3310=$3309; + var $3311=$3310; + var $3312=(($3311+8)|0); + var $3313=HEAPF32[(($3312)>>2)]; + var $3314=($3300)*($3313); + var $3315=$2; + var $3316=(($3315+64)|0); + var $3317=HEAP32[(($3316)>>2)]; + var $3318=$st; + var $3319=(($3318+6)|0); + var $3320=$3319; + var $3321=HEAP16[(($3320)>>1)]; + var $3322=(($3321)&65535); + var $3323=(($3317+($3322<<2))|0); + var $3324=$3323; + var $3325=$3324; + var $3326=(($3325+8)|0); + HEAPF32[(($3326)>>2)]=$3314; + __label__ = 245; break; + case 134: + var $3328=$2; + var $3329=(($3328+64)|0); + var $3330=HEAP32[(($3329)>>2)]; + var $3331=$st; + var $3332=(($3331+4)|0); + var $3333=$3332; + var $3334=HEAP16[(($3333)>>1)]; + var $3335=(($3334)&65535); + var $3336=(($3330+($3335<<2))|0); + var $3337=$3336; + var $3338=$3337; + var $3339=HEAPF32[(($3338)>>2)]; + var $3340=$2; + var $3341=(($3340+64)|0); + var $3342=HEAP32[(($3341)>>2)]; + var $3343=$st; + var $3344=(($3343+2)|0); + var $3345=$3344; + var $3346=HEAP16[(($3345)>>1)]; + var $3347=(($3346)&65535); + var $3348=(($3342+($3347<<2))|0); + var $3349=$3348; + var $3350=$3349; + var $3351=(($3350)|0); + var $3352=HEAPF32[(($3351)>>2)]; + var $3353=($3339)*($3352); + var $3354=$2; + var $3355=(($3354+64)|0); + var $3356=HEAP32[(($3355)>>2)]; + var $3357=$st; + var $3358=(($3357+6)|0); + var $3359=$3358; + var $3360=HEAP16[(($3359)>>1)]; + var $3361=(($3360)&65535); + var $3362=(($3356+($3361<<2))|0); + var $3363=$3362; + var $3364=$3363; + var $3365=(($3364)|0); + HEAPF32[(($3365)>>2)]=$3353; + var $3366=$2; + var $3367=(($3366+64)|0); + var $3368=HEAP32[(($3367)>>2)]; + var $3369=$st; + var $3370=(($3369+4)|0); + var $3371=$3370; + var $3372=HEAP16[(($3371)>>1)]; + var $3373=(($3372)&65535); + var $3374=(($3368+($3373<<2))|0); + var $3375=$3374; + var $3376=$3375; + var $3377=HEAPF32[(($3376)>>2)]; + var $3378=$2; + var $3379=(($3378+64)|0); + var $3380=HEAP32[(($3379)>>2)]; + var $3381=$st; + var $3382=(($3381+2)|0); + var $3383=$3382; + var $3384=HEAP16[(($3383)>>1)]; + var $3385=(($3384)&65535); + var $3386=(($3380+($3385<<2))|0); + var $3387=$3386; + var $3388=$3387; + var $3389=(($3388+4)|0); + var $3390=HEAPF32[(($3389)>>2)]; + var $3391=($3377)*($3390); + var $3392=$2; + var $3393=(($3392+64)|0); + var $3394=HEAP32[(($3393)>>2)]; + var $3395=$st; + var $3396=(($3395+6)|0); + var $3397=$3396; + var $3398=HEAP16[(($3397)>>1)]; + var $3399=(($3398)&65535); + var $3400=(($3394+($3399<<2))|0); + var $3401=$3400; + var $3402=$3401; + var $3403=(($3402+4)|0); + HEAPF32[(($3403)>>2)]=$3391; + var $3404=$2; + var $3405=(($3404+64)|0); + var $3406=HEAP32[(($3405)>>2)]; + var $3407=$st; + var $3408=(($3407+4)|0); + var $3409=$3408; + var $3410=HEAP16[(($3409)>>1)]; + var $3411=(($3410)&65535); + var $3412=(($3406+($3411<<2))|0); + var $3413=$3412; + var $3414=$3413; + var $3415=HEAPF32[(($3414)>>2)]; + var $3416=$2; + var $3417=(($3416+64)|0); + var $3418=HEAP32[(($3417)>>2)]; + var $3419=$st; + var $3420=(($3419+2)|0); + var $3421=$3420; + var $3422=HEAP16[(($3421)>>1)]; + var $3423=(($3422)&65535); + var $3424=(($3418+($3423<<2))|0); + var $3425=$3424; + var $3426=$3425; + var $3427=(($3426+8)|0); + var $3428=HEAPF32[(($3427)>>2)]; + var $3429=($3415)*($3428); + var $3430=$2; + var $3431=(($3430+64)|0); + var $3432=HEAP32[(($3431)>>2)]; + var $3433=$st; + var $3434=(($3433+6)|0); + var $3435=$3434; + var $3436=HEAP16[(($3435)>>1)]; + var $3437=(($3436)&65535); + var $3438=(($3432+($3437<<2))|0); + var $3439=$3438; + var $3440=$3439; + var $3441=(($3440+8)|0); + HEAPF32[(($3441)>>2)]=$3429; + __label__ = 245; break; + case 135: + var $3443=$2; + var $3444=(($3443+64)|0); + var $3445=HEAP32[(($3444)>>2)]; + var $3446=$st; + var $3447=(($3446+4)|0); + var $3448=$3447; + var $3449=HEAP16[(($3448)>>1)]; + var $3450=(($3449)&65535); + var $3451=(($3445+($3450<<2))|0); + var $3452=$3451; + var $3453=$3452; + var $3454=HEAPF32[(($3453)>>2)]; + var $3455=$3454 != 0; + if ($3455) { __label__ = 136; break; } else { __label__ = 137; break; } + case 136: + var $3457=$2; + var $3458=(($3457+64)|0); + var $3459=HEAP32[(($3458)>>2)]; + var $3460=$st; + var $3461=(($3460+2)|0); + var $3462=$3461; + var $3463=HEAP16[(($3462)>>1)]; + var $3464=(($3463)&65535); + var $3465=(($3459+($3464<<2))|0); + var $3466=$3465; + var $3467=$3466; + var $3468=HEAPF32[(($3467)>>2)]; + var $3469=$2; + var $3470=(($3469+64)|0); + var $3471=HEAP32[(($3470)>>2)]; + var $3472=$st; + var $3473=(($3472+4)|0); + var $3474=$3473; + var $3475=HEAP16[(($3474)>>1)]; + var $3476=(($3475)&65535); + var $3477=(($3471+($3476<<2))|0); + var $3478=$3477; + var $3479=$3478; + var $3480=HEAPF32[(($3479)>>2)]; + var $3481=($3468)/($3480); + var $3482=$2; + var $3483=(($3482+64)|0); + var $3484=HEAP32[(($3483)>>2)]; + var $3485=$st; + var $3486=(($3485+6)|0); + var $3487=$3486; + var $3488=HEAP16[(($3487)>>1)]; + var $3489=(($3488)&65535); + var $3490=(($3484+($3489<<2))|0); + var $3491=$3490; + var $3492=$3491; + HEAPF32[(($3492)>>2)]=$3481; + __label__ = 138; break; + case 137: + var $3494=$2; + var $3495=(($3494+64)|0); + var $3496=HEAP32[(($3495)>>2)]; + var $3497=$st; + var $3498=(($3497+6)|0); + var $3499=$3498; + var $3500=HEAP16[(($3499)>>1)]; + var $3501=(($3500)&65535); + var $3502=(($3496+($3501<<2))|0); + var $3503=$3502; + var $3504=$3503; + HEAPF32[(($3504)>>2)]=0; + __label__ = 138; break; + case 138: + __label__ = 245; break; + case 139: + var $3507=$2; + var $3508=(($3507+64)|0); + var $3509=HEAP32[(($3508)>>2)]; + var $3510=$st; + var $3511=(($3510+2)|0); + var $3512=$3511; + var $3513=HEAP16[(($3512)>>1)]; + var $3514=(($3513)&65535); + var $3515=(($3509+($3514<<2))|0); + var $3516=$3515; + var $3517=$3516; + var $3518=HEAPF32[(($3517)>>2)]; + var $3519=$2; + var $3520=(($3519+64)|0); + var $3521=HEAP32[(($3520)>>2)]; + var $3522=$st; + var $3523=(($3522+4)|0); + var $3524=$3523; + var $3525=HEAP16[(($3524)>>1)]; + var $3526=(($3525)&65535); + var $3527=(($3521+($3526<<2))|0); + var $3528=$3527; + var $3529=$3528; + var $3530=HEAPF32[(($3529)>>2)]; + var $3531=($3518)+($3530); + var $3532=$2; + var $3533=(($3532+64)|0); + var $3534=HEAP32[(($3533)>>2)]; + var $3535=$st; + var $3536=(($3535+6)|0); + var $3537=$3536; + var $3538=HEAP16[(($3537)>>1)]; + var $3539=(($3538)&65535); + var $3540=(($3534+($3539<<2))|0); + var $3541=$3540; + var $3542=$3541; + HEAPF32[(($3542)>>2)]=$3531; + __label__ = 245; break; + case 140: + var $3544=$2; + var $3545=(($3544+64)|0); + var $3546=HEAP32[(($3545)>>2)]; + var $3547=$st; + var $3548=(($3547+2)|0); + var $3549=$3548; + var $3550=HEAP16[(($3549)>>1)]; + var $3551=(($3550)&65535); + var $3552=(($3546+($3551<<2))|0); + var $3553=$3552; + var $3554=$3553; + var $3555=(($3554)|0); + var $3556=HEAPF32[(($3555)>>2)]; + var $3557=$2; + var $3558=(($3557+64)|0); + var $3559=HEAP32[(($3558)>>2)]; + var $3560=$st; + var $3561=(($3560+4)|0); + var $3562=$3561; + var $3563=HEAP16[(($3562)>>1)]; + var $3564=(($3563)&65535); + var $3565=(($3559+($3564<<2))|0); + var $3566=$3565; + var $3567=$3566; + var $3568=(($3567)|0); + var $3569=HEAPF32[(($3568)>>2)]; + var $3570=($3556)+($3569); + var $3571=$2; + var $3572=(($3571+64)|0); + var $3573=HEAP32[(($3572)>>2)]; + var $3574=$st; + var $3575=(($3574+6)|0); + var $3576=$3575; + var $3577=HEAP16[(($3576)>>1)]; + var $3578=(($3577)&65535); + var $3579=(($3573+($3578<<2))|0); + var $3580=$3579; + var $3581=$3580; + var $3582=(($3581)|0); + HEAPF32[(($3582)>>2)]=$3570; + var $3583=$2; + var $3584=(($3583+64)|0); + var $3585=HEAP32[(($3584)>>2)]; + var $3586=$st; + var $3587=(($3586+2)|0); + var $3588=$3587; + var $3589=HEAP16[(($3588)>>1)]; + var $3590=(($3589)&65535); + var $3591=(($3585+($3590<<2))|0); + var $3592=$3591; + var $3593=$3592; + var $3594=(($3593+4)|0); + var $3595=HEAPF32[(($3594)>>2)]; + var $3596=$2; + var $3597=(($3596+64)|0); + var $3598=HEAP32[(($3597)>>2)]; + var $3599=$st; + var $3600=(($3599+4)|0); + var $3601=$3600; + var $3602=HEAP16[(($3601)>>1)]; + var $3603=(($3602)&65535); + var $3604=(($3598+($3603<<2))|0); + var $3605=$3604; + var $3606=$3605; + var $3607=(($3606+4)|0); + var $3608=HEAPF32[(($3607)>>2)]; + var $3609=($3595)+($3608); + var $3610=$2; + var $3611=(($3610+64)|0); + var $3612=HEAP32[(($3611)>>2)]; + var $3613=$st; + var $3614=(($3613+6)|0); + var $3615=$3614; + var $3616=HEAP16[(($3615)>>1)]; + var $3617=(($3616)&65535); + var $3618=(($3612+($3617<<2))|0); + var $3619=$3618; + var $3620=$3619; + var $3621=(($3620+4)|0); + HEAPF32[(($3621)>>2)]=$3609; + var $3622=$2; + var $3623=(($3622+64)|0); + var $3624=HEAP32[(($3623)>>2)]; + var $3625=$st; + var $3626=(($3625+2)|0); + var $3627=$3626; + var $3628=HEAP16[(($3627)>>1)]; + var $3629=(($3628)&65535); + var $3630=(($3624+($3629<<2))|0); + var $3631=$3630; + var $3632=$3631; + var $3633=(($3632+8)|0); + var $3634=HEAPF32[(($3633)>>2)]; + var $3635=$2; + var $3636=(($3635+64)|0); + var $3637=HEAP32[(($3636)>>2)]; + var $3638=$st; + var $3639=(($3638+4)|0); + var $3640=$3639; + var $3641=HEAP16[(($3640)>>1)]; + var $3642=(($3641)&65535); + var $3643=(($3637+($3642<<2))|0); + var $3644=$3643; + var $3645=$3644; + var $3646=(($3645+8)|0); + var $3647=HEAPF32[(($3646)>>2)]; + var $3648=($3634)+($3647); + var $3649=$2; + var $3650=(($3649+64)|0); + var $3651=HEAP32[(($3650)>>2)]; + var $3652=$st; + var $3653=(($3652+6)|0); + var $3654=$3653; + var $3655=HEAP16[(($3654)>>1)]; + var $3656=(($3655)&65535); + var $3657=(($3651+($3656<<2))|0); + var $3658=$3657; + var $3659=$3658; + var $3660=(($3659+8)|0); + HEAPF32[(($3660)>>2)]=$3648; + __label__ = 245; break; + case 141: + var $3662=$2; + var $3663=(($3662+64)|0); + var $3664=HEAP32[(($3663)>>2)]; + var $3665=$st; + var $3666=(($3665+2)|0); + var $3667=$3666; + var $3668=HEAP16[(($3667)>>1)]; + var $3669=(($3668)&65535); + var $3670=(($3664+($3669<<2))|0); + var $3671=$3670; + var $3672=$3671; + var $3673=HEAPF32[(($3672)>>2)]; + var $3674=$2; + var $3675=(($3674+64)|0); + var $3676=HEAP32[(($3675)>>2)]; + var $3677=$st; + var $3678=(($3677+4)|0); + var $3679=$3678; + var $3680=HEAP16[(($3679)>>1)]; + var $3681=(($3680)&65535); + var $3682=(($3676+($3681<<2))|0); + var $3683=$3682; + var $3684=$3683; + var $3685=HEAPF32[(($3684)>>2)]; + var $3686=($3673)-($3685); + var $3687=$2; + var $3688=(($3687+64)|0); + var $3689=HEAP32[(($3688)>>2)]; + var $3690=$st; + var $3691=(($3690+6)|0); + var $3692=$3691; + var $3693=HEAP16[(($3692)>>1)]; + var $3694=(($3693)&65535); + var $3695=(($3689+($3694<<2))|0); + var $3696=$3695; + var $3697=$3696; + HEAPF32[(($3697)>>2)]=$3686; + __label__ = 245; break; + case 142: + var $3699=$2; + var $3700=(($3699+64)|0); + var $3701=HEAP32[(($3700)>>2)]; + var $3702=$st; + var $3703=(($3702+2)|0); + var $3704=$3703; + var $3705=HEAP16[(($3704)>>1)]; + var $3706=(($3705)&65535); + var $3707=(($3701+($3706<<2))|0); + var $3708=$3707; + var $3709=$3708; + var $3710=(($3709)|0); + var $3711=HEAPF32[(($3710)>>2)]; + var $3712=$2; + var $3713=(($3712+64)|0); + var $3714=HEAP32[(($3713)>>2)]; + var $3715=$st; + var $3716=(($3715+4)|0); + var $3717=$3716; + var $3718=HEAP16[(($3717)>>1)]; + var $3719=(($3718)&65535); + var $3720=(($3714+($3719<<2))|0); + var $3721=$3720; + var $3722=$3721; + var $3723=(($3722)|0); + var $3724=HEAPF32[(($3723)>>2)]; + var $3725=($3711)-($3724); + var $3726=$2; + var $3727=(($3726+64)|0); + var $3728=HEAP32[(($3727)>>2)]; + var $3729=$st; + var $3730=(($3729+6)|0); + var $3731=$3730; + var $3732=HEAP16[(($3731)>>1)]; + var $3733=(($3732)&65535); + var $3734=(($3728+($3733<<2))|0); + var $3735=$3734; + var $3736=$3735; + var $3737=(($3736)|0); + HEAPF32[(($3737)>>2)]=$3725; + var $3738=$2; + var $3739=(($3738+64)|0); + var $3740=HEAP32[(($3739)>>2)]; + var $3741=$st; + var $3742=(($3741+2)|0); + var $3743=$3742; + var $3744=HEAP16[(($3743)>>1)]; + var $3745=(($3744)&65535); + var $3746=(($3740+($3745<<2))|0); + var $3747=$3746; + var $3748=$3747; + var $3749=(($3748+4)|0); + var $3750=HEAPF32[(($3749)>>2)]; + var $3751=$2; + var $3752=(($3751+64)|0); + var $3753=HEAP32[(($3752)>>2)]; + var $3754=$st; + var $3755=(($3754+4)|0); + var $3756=$3755; + var $3757=HEAP16[(($3756)>>1)]; + var $3758=(($3757)&65535); + var $3759=(($3753+($3758<<2))|0); + var $3760=$3759; + var $3761=$3760; + var $3762=(($3761+4)|0); + var $3763=HEAPF32[(($3762)>>2)]; + var $3764=($3750)-($3763); + var $3765=$2; + var $3766=(($3765+64)|0); + var $3767=HEAP32[(($3766)>>2)]; + var $3768=$st; + var $3769=(($3768+6)|0); + var $3770=$3769; + var $3771=HEAP16[(($3770)>>1)]; + var $3772=(($3771)&65535); + var $3773=(($3767+($3772<<2))|0); + var $3774=$3773; + var $3775=$3774; + var $3776=(($3775+4)|0); + HEAPF32[(($3776)>>2)]=$3764; + var $3777=$2; + var $3778=(($3777+64)|0); + var $3779=HEAP32[(($3778)>>2)]; + var $3780=$st; + var $3781=(($3780+2)|0); + var $3782=$3781; + var $3783=HEAP16[(($3782)>>1)]; + var $3784=(($3783)&65535); + var $3785=(($3779+($3784<<2))|0); + var $3786=$3785; + var $3787=$3786; + var $3788=(($3787+8)|0); + var $3789=HEAPF32[(($3788)>>2)]; + var $3790=$2; + var $3791=(($3790+64)|0); + var $3792=HEAP32[(($3791)>>2)]; + var $3793=$st; + var $3794=(($3793+4)|0); + var $3795=$3794; + var $3796=HEAP16[(($3795)>>1)]; + var $3797=(($3796)&65535); + var $3798=(($3792+($3797<<2))|0); + var $3799=$3798; + var $3800=$3799; + var $3801=(($3800+8)|0); + var $3802=HEAPF32[(($3801)>>2)]; + var $3803=($3789)-($3802); + var $3804=$2; + var $3805=(($3804+64)|0); + var $3806=HEAP32[(($3805)>>2)]; + var $3807=$st; + var $3808=(($3807+6)|0); + var $3809=$3808; + var $3810=HEAP16[(($3809)>>1)]; + var $3811=(($3810)&65535); + var $3812=(($3806+($3811<<2))|0); + var $3813=$3812; + var $3814=$3813; + var $3815=(($3814+8)|0); + HEAPF32[(($3815)>>2)]=$3803; + __label__ = 245; break; + case 143: + var $3817=$2; + var $3818=(($3817+64)|0); + var $3819=HEAP32[(($3818)>>2)]; + var $3820=$st; + var $3821=(($3820+2)|0); + var $3822=$3821; + var $3823=HEAP16[(($3822)>>1)]; + var $3824=(($3823)&65535); + var $3825=(($3819+($3824<<2))|0); + var $3826=$3825; + var $3827=$3826; + var $3828=HEAPF32[(($3827)>>2)]; + var $3829=$2; + var $3830=(($3829+64)|0); + var $3831=HEAP32[(($3830)>>2)]; + var $3832=$st; + var $3833=(($3832+4)|0); + var $3834=$3833; + var $3835=HEAP16[(($3834)>>1)]; + var $3836=(($3835)&65535); + var $3837=(($3831+($3836<<2))|0); + var $3838=$3837; + var $3839=$3838; + var $3840=HEAPF32[(($3839)>>2)]; + var $3841=$3828 == $3840; + var $3842=(($3841)&1); + var $3843=(($3842)|0); + var $3844=$2; + var $3845=(($3844+64)|0); + var $3846=HEAP32[(($3845)>>2)]; + var $3847=$st; + var $3848=(($3847+6)|0); + var $3849=$3848; + var $3850=HEAP16[(($3849)>>1)]; + var $3851=(($3850)&65535); + var $3852=(($3846+($3851<<2))|0); + var $3853=$3852; + var $3854=$3853; + HEAPF32[(($3854)>>2)]=$3843; + __label__ = 245; break; + case 144: + var $3856=$2; + var $3857=(($3856+64)|0); + var $3858=HEAP32[(($3857)>>2)]; + var $3859=$st; + var $3860=(($3859+2)|0); + var $3861=$3860; + var $3862=HEAP16[(($3861)>>1)]; + var $3863=(($3862)&65535); + var $3864=(($3858+($3863<<2))|0); + var $3865=$3864; + var $3866=$3865; + var $3867=(($3866)|0); + var $3868=HEAPF32[(($3867)>>2)]; + var $3869=$2; + var $3870=(($3869+64)|0); + var $3871=HEAP32[(($3870)>>2)]; + var $3872=$st; + var $3873=(($3872+4)|0); + var $3874=$3873; + var $3875=HEAP16[(($3874)>>1)]; + var $3876=(($3875)&65535); + var $3877=(($3871+($3876<<2))|0); + var $3878=$3877; + var $3879=$3878; + var $3880=(($3879)|0); + var $3881=HEAPF32[(($3880)>>2)]; + var $3882=$3868 == $3881; + if ($3882) { __label__ = 145; break; } else { var $3940 = 0;__label__ = 147; break; } + case 145: + var $3884=$2; + var $3885=(($3884+64)|0); + var $3886=HEAP32[(($3885)>>2)]; + var $3887=$st; + var $3888=(($3887+2)|0); + var $3889=$3888; + var $3890=HEAP16[(($3889)>>1)]; + var $3891=(($3890)&65535); + var $3892=(($3886+($3891<<2))|0); + var $3893=$3892; + var $3894=$3893; + var $3895=(($3894+4)|0); + var $3896=HEAPF32[(($3895)>>2)]; + var $3897=$2; + var $3898=(($3897+64)|0); + var $3899=HEAP32[(($3898)>>2)]; + var $3900=$st; + var $3901=(($3900+4)|0); + var $3902=$3901; + var $3903=HEAP16[(($3902)>>1)]; + var $3904=(($3903)&65535); + var $3905=(($3899+($3904<<2))|0); + var $3906=$3905; + var $3907=$3906; + var $3908=(($3907+4)|0); + var $3909=HEAPF32[(($3908)>>2)]; + var $3910=$3896 == $3909; + if ($3910) { __label__ = 146; break; } else { var $3940 = 0;__label__ = 147; break; } + case 146: + var $3912=$2; + var $3913=(($3912+64)|0); + var $3914=HEAP32[(($3913)>>2)]; + var $3915=$st; + var $3916=(($3915+2)|0); + var $3917=$3916; + var $3918=HEAP16[(($3917)>>1)]; + var $3919=(($3918)&65535); + var $3920=(($3914+($3919<<2))|0); + var $3921=$3920; + var $3922=$3921; + var $3923=(($3922+8)|0); + var $3924=HEAPF32[(($3923)>>2)]; + var $3925=$2; + var $3926=(($3925+64)|0); + var $3927=HEAP32[(($3926)>>2)]; + var $3928=$st; + var $3929=(($3928+4)|0); + var $3930=$3929; + var $3931=HEAP16[(($3930)>>1)]; + var $3932=(($3931)&65535); + var $3933=(($3927+($3932<<2))|0); + var $3934=$3933; + var $3935=$3934; + var $3936=(($3935+8)|0); + var $3937=HEAPF32[(($3936)>>2)]; + var $3938=$3924 == $3937; + var $3940 = $3938;__label__ = 147; break; + case 147: + var $3940; + var $3941=(($3940)&1); + var $3942=(($3941)|0); + var $3943=$2; + var $3944=(($3943+64)|0); + var $3945=HEAP32[(($3944)>>2)]; + var $3946=$st; + var $3947=(($3946+6)|0); + var $3948=$3947; + var $3949=HEAP16[(($3948)>>1)]; + var $3950=(($3949)&65535); + var $3951=(($3945+($3950<<2))|0); + var $3952=$3951; + var $3953=$3952; + HEAPF32[(($3953)>>2)]=$3942; + __label__ = 245; break; + case 148: + var $3955=$2; + var $3956=$2; + var $3957=(($3956+64)|0); + var $3958=HEAP32[(($3957)>>2)]; + var $3959=$st; + var $3960=(($3959+2)|0); + var $3961=$3960; + var $3962=HEAP16[(($3961)>>1)]; + var $3963=(($3962)&65535); + var $3964=(($3958+($3963<<2))|0); + var $3965=$3964; + var $3966=$3965; + var $3967=HEAP32[(($3966)>>2)]; + var $3968=_prog_getstring($3955, $3967); + var $3969=$2; + var $3970=$2; + var $3971=(($3970+64)|0); + var $3972=HEAP32[(($3971)>>2)]; + var $3973=$st; + var $3974=(($3973+4)|0); + var $3975=$3974; + var $3976=HEAP16[(($3975)>>1)]; + var $3977=(($3976)&65535); + var $3978=(($3972+($3977<<2))|0); + var $3979=$3978; + var $3980=$3979; + var $3981=HEAP32[(($3980)>>2)]; + var $3982=_prog_getstring($3969, $3981); + var $3983=_strcmp($3968, $3982); + var $3984=(($3983)|0)!=0; + var $3985=$3984 ^ 1; + var $3986=(($3985)&1); + var $3987=(($3986)|0); + var $3988=$2; + var $3989=(($3988+64)|0); + var $3990=HEAP32[(($3989)>>2)]; + var $3991=$st; + var $3992=(($3991+6)|0); + var $3993=$3992; + var $3994=HEAP16[(($3993)>>1)]; + var $3995=(($3994)&65535); + var $3996=(($3990+($3995<<2))|0); + var $3997=$3996; + var $3998=$3997; + HEAPF32[(($3998)>>2)]=$3987; + __label__ = 245; break; + case 149: + var $4000=$2; + var $4001=(($4000+64)|0); + var $4002=HEAP32[(($4001)>>2)]; + var $4003=$st; + var $4004=(($4003+2)|0); + var $4005=$4004; + var $4006=HEAP16[(($4005)>>1)]; + var $4007=(($4006)&65535); + var $4008=(($4002+($4007<<2))|0); + var $4009=$4008; + var $4010=$4009; + var $4011=HEAP32[(($4010)>>2)]; + var $4012=$2; + var $4013=(($4012+64)|0); + var $4014=HEAP32[(($4013)>>2)]; + var $4015=$st; + var $4016=(($4015+4)|0); + var $4017=$4016; + var $4018=HEAP16[(($4017)>>1)]; + var $4019=(($4018)&65535); + var $4020=(($4014+($4019<<2))|0); + var $4021=$4020; + var $4022=$4021; + var $4023=HEAP32[(($4022)>>2)]; + var $4024=(($4011)|0)==(($4023)|0); + var $4025=(($4024)&1); + var $4026=(($4025)|0); + var $4027=$2; + var $4028=(($4027+64)|0); + var $4029=HEAP32[(($4028)>>2)]; + var $4030=$st; + var $4031=(($4030+6)|0); + var $4032=$4031; + var $4033=HEAP16[(($4032)>>1)]; + var $4034=(($4033)&65535); + var $4035=(($4029+($4034<<2))|0); + var $4036=$4035; + var $4037=$4036; + HEAPF32[(($4037)>>2)]=$4026; + __label__ = 245; break; + case 150: + var $4039=$2; + var $4040=(($4039+64)|0); + var $4041=HEAP32[(($4040)>>2)]; + var $4042=$st; + var $4043=(($4042+2)|0); + var $4044=$4043; + var $4045=HEAP16[(($4044)>>1)]; + var $4046=(($4045)&65535); + var $4047=(($4041+($4046<<2))|0); + var $4048=$4047; + var $4049=$4048; + var $4050=HEAP32[(($4049)>>2)]; + var $4051=$2; + var $4052=(($4051+64)|0); + var $4053=HEAP32[(($4052)>>2)]; + var $4054=$st; + var $4055=(($4054+4)|0); + var $4056=$4055; + var $4057=HEAP16[(($4056)>>1)]; + var $4058=(($4057)&65535); + var $4059=(($4053+($4058<<2))|0); + var $4060=$4059; + var $4061=$4060; + var $4062=HEAP32[(($4061)>>2)]; + var $4063=(($4050)|0)==(($4062)|0); + var $4064=(($4063)&1); + var $4065=(($4064)|0); + var $4066=$2; + var $4067=(($4066+64)|0); + var $4068=HEAP32[(($4067)>>2)]; + var $4069=$st; + var $4070=(($4069+6)|0); + var $4071=$4070; + var $4072=HEAP16[(($4071)>>1)]; + var $4073=(($4072)&65535); + var $4074=(($4068+($4073<<2))|0); + var $4075=$4074; + var $4076=$4075; + HEAPF32[(($4076)>>2)]=$4065; + __label__ = 245; break; + case 151: + var $4078=$2; + var $4079=(($4078+64)|0); + var $4080=HEAP32[(($4079)>>2)]; + var $4081=$st; + var $4082=(($4081+2)|0); + var $4083=$4082; + var $4084=HEAP16[(($4083)>>1)]; + var $4085=(($4084)&65535); + var $4086=(($4080+($4085<<2))|0); + var $4087=$4086; + var $4088=$4087; + var $4089=HEAPF32[(($4088)>>2)]; + var $4090=$2; + var $4091=(($4090+64)|0); + var $4092=HEAP32[(($4091)>>2)]; + var $4093=$st; + var $4094=(($4093+4)|0); + var $4095=$4094; + var $4096=HEAP16[(($4095)>>1)]; + var $4097=(($4096)&65535); + var $4098=(($4092+($4097<<2))|0); + var $4099=$4098; + var $4100=$4099; + var $4101=HEAPF32[(($4100)>>2)]; + var $4102=$4089 != $4101; + var $4103=(($4102)&1); + var $4104=(($4103)|0); + var $4105=$2; + var $4106=(($4105+64)|0); + var $4107=HEAP32[(($4106)>>2)]; + var $4108=$st; + var $4109=(($4108+6)|0); + var $4110=$4109; + var $4111=HEAP16[(($4110)>>1)]; + var $4112=(($4111)&65535); + var $4113=(($4107+($4112<<2))|0); + var $4114=$4113; + var $4115=$4114; + HEAPF32[(($4115)>>2)]=$4104; + __label__ = 245; break; + case 152: + var $4117=$2; + var $4118=(($4117+64)|0); + var $4119=HEAP32[(($4118)>>2)]; + var $4120=$st; + var $4121=(($4120+2)|0); + var $4122=$4121; + var $4123=HEAP16[(($4122)>>1)]; + var $4124=(($4123)&65535); + var $4125=(($4119+($4124<<2))|0); + var $4126=$4125; + var $4127=$4126; + var $4128=(($4127)|0); + var $4129=HEAPF32[(($4128)>>2)]; + var $4130=$2; + var $4131=(($4130+64)|0); + var $4132=HEAP32[(($4131)>>2)]; + var $4133=$st; + var $4134=(($4133+4)|0); + var $4135=$4134; + var $4136=HEAP16[(($4135)>>1)]; + var $4137=(($4136)&65535); + var $4138=(($4132+($4137<<2))|0); + var $4139=$4138; + var $4140=$4139; + var $4141=(($4140)|0); + var $4142=HEAPF32[(($4141)>>2)]; + var $4143=$4129 != $4142; + if ($4143) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 153; break; } + case 153: + var $4145=$2; + var $4146=(($4145+64)|0); + var $4147=HEAP32[(($4146)>>2)]; + var $4148=$st; + var $4149=(($4148+2)|0); + var $4150=$4149; + var $4151=HEAP16[(($4150)>>1)]; + var $4152=(($4151)&65535); + var $4153=(($4147+($4152<<2))|0); + var $4154=$4153; + var $4155=$4154; + var $4156=(($4155+4)|0); + var $4157=HEAPF32[(($4156)>>2)]; + var $4158=$2; + var $4159=(($4158+64)|0); + var $4160=HEAP32[(($4159)>>2)]; + var $4161=$st; + var $4162=(($4161+4)|0); + var $4163=$4162; + var $4164=HEAP16[(($4163)>>1)]; + var $4165=(($4164)&65535); + var $4166=(($4160+($4165<<2))|0); + var $4167=$4166; + var $4168=$4167; + var $4169=(($4168+4)|0); + var $4170=HEAPF32[(($4169)>>2)]; + var $4171=$4157 != $4170; + if ($4171) { var $4201 = 1;__label__ = 155; break; } else { __label__ = 154; break; } + case 154: + var $4173=$2; + var $4174=(($4173+64)|0); + var $4175=HEAP32[(($4174)>>2)]; + var $4176=$st; + var $4177=(($4176+2)|0); + var $4178=$4177; + var $4179=HEAP16[(($4178)>>1)]; + var $4180=(($4179)&65535); + var $4181=(($4175+($4180<<2))|0); + var $4182=$4181; + var $4183=$4182; + var $4184=(($4183+8)|0); + var $4185=HEAPF32[(($4184)>>2)]; + var $4186=$2; + var $4187=(($4186+64)|0); + var $4188=HEAP32[(($4187)>>2)]; + var $4189=$st; + var $4190=(($4189+4)|0); + var $4191=$4190; + var $4192=HEAP16[(($4191)>>1)]; + var $4193=(($4192)&65535); + var $4194=(($4188+($4193<<2))|0); + var $4195=$4194; + var $4196=$4195; + var $4197=(($4196+8)|0); + var $4198=HEAPF32[(($4197)>>2)]; + var $4199=$4185 != $4198; + var $4201 = $4199;__label__ = 155; break; + case 155: + var $4201; + var $4202=(($4201)&1); + var $4203=(($4202)|0); + var $4204=$2; + var $4205=(($4204+64)|0); + var $4206=HEAP32[(($4205)>>2)]; + var $4207=$st; + var $4208=(($4207+6)|0); + var $4209=$4208; + var $4210=HEAP16[(($4209)>>1)]; + var $4211=(($4210)&65535); + var $4212=(($4206+($4211<<2))|0); + var $4213=$4212; + var $4214=$4213; + HEAPF32[(($4214)>>2)]=$4203; + __label__ = 245; break; + case 156: + var $4216=$2; + var $4217=$2; + var $4218=(($4217+64)|0); + var $4219=HEAP32[(($4218)>>2)]; + var $4220=$st; + var $4221=(($4220+2)|0); + var $4222=$4221; + var $4223=HEAP16[(($4222)>>1)]; + var $4224=(($4223)&65535); + var $4225=(($4219+($4224<<2))|0); + var $4226=$4225; + var $4227=$4226; + var $4228=HEAP32[(($4227)>>2)]; + var $4229=_prog_getstring($4216, $4228); + var $4230=$2; + var $4231=$2; + var $4232=(($4231+64)|0); + var $4233=HEAP32[(($4232)>>2)]; + var $4234=$st; + var $4235=(($4234+4)|0); + var $4236=$4235; + var $4237=HEAP16[(($4236)>>1)]; + var $4238=(($4237)&65535); + var $4239=(($4233+($4238<<2))|0); + var $4240=$4239; + var $4241=$4240; + var $4242=HEAP32[(($4241)>>2)]; + var $4243=_prog_getstring($4230, $4242); + var $4244=_strcmp($4229, $4243); + var $4245=(($4244)|0)!=0; + var $4246=$4245 ^ 1; + var $4247=$4246 ^ 1; + var $4248=(($4247)&1); + var $4249=(($4248)|0); + var $4250=$2; + var $4251=(($4250+64)|0); + var $4252=HEAP32[(($4251)>>2)]; + var $4253=$st; + var $4254=(($4253+6)|0); + var $4255=$4254; + var $4256=HEAP16[(($4255)>>1)]; + var $4257=(($4256)&65535); + var $4258=(($4252+($4257<<2))|0); + var $4259=$4258; + var $4260=$4259; + HEAPF32[(($4260)>>2)]=$4249; + __label__ = 245; break; + case 157: + var $4262=$2; + var $4263=(($4262+64)|0); + var $4264=HEAP32[(($4263)>>2)]; + var $4265=$st; + var $4266=(($4265+2)|0); + var $4267=$4266; + var $4268=HEAP16[(($4267)>>1)]; + var $4269=(($4268)&65535); + var $4270=(($4264+($4269<<2))|0); + var $4271=$4270; + var $4272=$4271; + var $4273=HEAP32[(($4272)>>2)]; + var $4274=$2; + var $4275=(($4274+64)|0); + var $4276=HEAP32[(($4275)>>2)]; + var $4277=$st; + var $4278=(($4277+4)|0); + var $4279=$4278; + var $4280=HEAP16[(($4279)>>1)]; + var $4281=(($4280)&65535); + var $4282=(($4276+($4281<<2))|0); + var $4283=$4282; + var $4284=$4283; + var $4285=HEAP32[(($4284)>>2)]; + var $4286=(($4273)|0)!=(($4285)|0); + var $4287=(($4286)&1); + var $4288=(($4287)|0); + var $4289=$2; + var $4290=(($4289+64)|0); + var $4291=HEAP32[(($4290)>>2)]; + var $4292=$st; + var $4293=(($4292+6)|0); + var $4294=$4293; + var $4295=HEAP16[(($4294)>>1)]; + var $4296=(($4295)&65535); + var $4297=(($4291+($4296<<2))|0); + var $4298=$4297; + var $4299=$4298; + HEAPF32[(($4299)>>2)]=$4288; + __label__ = 245; break; + case 158: + var $4301=$2; + var $4302=(($4301+64)|0); + var $4303=HEAP32[(($4302)>>2)]; + var $4304=$st; + var $4305=(($4304+2)|0); + var $4306=$4305; + var $4307=HEAP16[(($4306)>>1)]; + var $4308=(($4307)&65535); + var $4309=(($4303+($4308<<2))|0); + var $4310=$4309; + var $4311=$4310; + var $4312=HEAP32[(($4311)>>2)]; + var $4313=$2; + var $4314=(($4313+64)|0); + var $4315=HEAP32[(($4314)>>2)]; + var $4316=$st; + var $4317=(($4316+4)|0); + var $4318=$4317; + var $4319=HEAP16[(($4318)>>1)]; + var $4320=(($4319)&65535); + var $4321=(($4315+($4320<<2))|0); + var $4322=$4321; + var $4323=$4322; + var $4324=HEAP32[(($4323)>>2)]; + var $4325=(($4312)|0)!=(($4324)|0); + var $4326=(($4325)&1); + var $4327=(($4326)|0); + var $4328=$2; + var $4329=(($4328+64)|0); + var $4330=HEAP32[(($4329)>>2)]; + var $4331=$st; + var $4332=(($4331+6)|0); + var $4333=$4332; + var $4334=HEAP16[(($4333)>>1)]; + var $4335=(($4334)&65535); + var $4336=(($4330+($4335<<2))|0); + var $4337=$4336; + var $4338=$4337; + HEAPF32[(($4338)>>2)]=$4327; + __label__ = 245; break; + case 159: + var $4340=$2; + var $4341=(($4340+64)|0); + var $4342=HEAP32[(($4341)>>2)]; + var $4343=$st; + var $4344=(($4343+2)|0); + var $4345=$4344; + var $4346=HEAP16[(($4345)>>1)]; + var $4347=(($4346)&65535); + var $4348=(($4342+($4347<<2))|0); + var $4349=$4348; + var $4350=$4349; + var $4351=HEAPF32[(($4350)>>2)]; + var $4352=$2; + var $4353=(($4352+64)|0); + var $4354=HEAP32[(($4353)>>2)]; + var $4355=$st; + var $4356=(($4355+4)|0); + var $4357=$4356; + var $4358=HEAP16[(($4357)>>1)]; + var $4359=(($4358)&65535); + var $4360=(($4354+($4359<<2))|0); + var $4361=$4360; + var $4362=$4361; + var $4363=HEAPF32[(($4362)>>2)]; + var $4364=$4351 <= $4363; + var $4365=(($4364)&1); + var $4366=(($4365)|0); + var $4367=$2; + var $4368=(($4367+64)|0); + var $4369=HEAP32[(($4368)>>2)]; + var $4370=$st; + var $4371=(($4370+6)|0); + var $4372=$4371; + var $4373=HEAP16[(($4372)>>1)]; + var $4374=(($4373)&65535); + var $4375=(($4369+($4374<<2))|0); + var $4376=$4375; + var $4377=$4376; + HEAPF32[(($4377)>>2)]=$4366; + __label__ = 245; break; + case 160: + var $4379=$2; + var $4380=(($4379+64)|0); + var $4381=HEAP32[(($4380)>>2)]; + var $4382=$st; + var $4383=(($4382+2)|0); + var $4384=$4383; + var $4385=HEAP16[(($4384)>>1)]; + var $4386=(($4385)&65535); + var $4387=(($4381+($4386<<2))|0); + var $4388=$4387; + var $4389=$4388; + var $4390=HEAPF32[(($4389)>>2)]; + var $4391=$2; + var $4392=(($4391+64)|0); + var $4393=HEAP32[(($4392)>>2)]; + var $4394=$st; + var $4395=(($4394+4)|0); + var $4396=$4395; + var $4397=HEAP16[(($4396)>>1)]; + var $4398=(($4397)&65535); + var $4399=(($4393+($4398<<2))|0); + var $4400=$4399; + var $4401=$4400; + var $4402=HEAPF32[(($4401)>>2)]; + var $4403=$4390 >= $4402; + var $4404=(($4403)&1); + var $4405=(($4404)|0); + var $4406=$2; + var $4407=(($4406+64)|0); + var $4408=HEAP32[(($4407)>>2)]; + var $4409=$st; + var $4410=(($4409+6)|0); + var $4411=$4410; + var $4412=HEAP16[(($4411)>>1)]; + var $4413=(($4412)&65535); + var $4414=(($4408+($4413<<2))|0); + var $4415=$4414; + var $4416=$4415; + HEAPF32[(($4416)>>2)]=$4405; + __label__ = 245; break; + case 161: + var $4418=$2; + var $4419=(($4418+64)|0); + var $4420=HEAP32[(($4419)>>2)]; + var $4421=$st; + var $4422=(($4421+2)|0); + var $4423=$4422; + var $4424=HEAP16[(($4423)>>1)]; + var $4425=(($4424)&65535); + var $4426=(($4420+($4425<<2))|0); + var $4427=$4426; + var $4428=$4427; + var $4429=HEAPF32[(($4428)>>2)]; + var $4430=$2; + var $4431=(($4430+64)|0); + var $4432=HEAP32[(($4431)>>2)]; + var $4433=$st; + var $4434=(($4433+4)|0); + var $4435=$4434; + var $4436=HEAP16[(($4435)>>1)]; + var $4437=(($4436)&65535); + var $4438=(($4432+($4437<<2))|0); + var $4439=$4438; + var $4440=$4439; + var $4441=HEAPF32[(($4440)>>2)]; + var $4442=$4429 < $4441; + var $4443=(($4442)&1); + var $4444=(($4443)|0); + var $4445=$2; + var $4446=(($4445+64)|0); + var $4447=HEAP32[(($4446)>>2)]; + var $4448=$st; + var $4449=(($4448+6)|0); + var $4450=$4449; + var $4451=HEAP16[(($4450)>>1)]; + var $4452=(($4451)&65535); + var $4453=(($4447+($4452<<2))|0); + var $4454=$4453; + var $4455=$4454; + HEAPF32[(($4455)>>2)]=$4444; + __label__ = 245; break; + case 162: + var $4457=$2; + var $4458=(($4457+64)|0); + var $4459=HEAP32[(($4458)>>2)]; + var $4460=$st; + var $4461=(($4460+2)|0); + var $4462=$4461; + var $4463=HEAP16[(($4462)>>1)]; + var $4464=(($4463)&65535); + var $4465=(($4459+($4464<<2))|0); + var $4466=$4465; + var $4467=$4466; + var $4468=HEAPF32[(($4467)>>2)]; + var $4469=$2; + var $4470=(($4469+64)|0); + var $4471=HEAP32[(($4470)>>2)]; + var $4472=$st; + var $4473=(($4472+4)|0); + var $4474=$4473; + var $4475=HEAP16[(($4474)>>1)]; + var $4476=(($4475)&65535); + var $4477=(($4471+($4476<<2))|0); + var $4478=$4477; + var $4479=$4478; + var $4480=HEAPF32[(($4479)>>2)]; + var $4481=$4468 > $4480; + var $4482=(($4481)&1); + var $4483=(($4482)|0); + var $4484=$2; + var $4485=(($4484+64)|0); + var $4486=HEAP32[(($4485)>>2)]; + var $4487=$st; + var $4488=(($4487+6)|0); + var $4489=$4488; + var $4490=HEAP16[(($4489)>>1)]; + var $4491=(($4490)&65535); + var $4492=(($4486+($4491<<2))|0); + var $4493=$4492; + var $4494=$4493; + HEAPF32[(($4494)>>2)]=$4483; + __label__ = 245; break; + case 163: + var $4496=$2; + var $4497=(($4496+64)|0); + var $4498=HEAP32[(($4497)>>2)]; + var $4499=$st; + var $4500=(($4499+2)|0); + var $4501=$4500; + var $4502=HEAP16[(($4501)>>1)]; + var $4503=(($4502)&65535); + var $4504=(($4498+($4503<<2))|0); + var $4505=$4504; + var $4506=$4505; + var $4507=HEAP32[(($4506)>>2)]; + var $4508=(($4507)|0) < 0; + if ($4508) { __label__ = 165; break; } else { __label__ = 164; break; } + case 164: + var $4510=$2; + var $4511=(($4510+64)|0); + var $4512=HEAP32[(($4511)>>2)]; + var $4513=$st; + var $4514=(($4513+2)|0); + var $4515=$4514; + var $4516=HEAP16[(($4515)>>1)]; + var $4517=(($4516)&65535); + var $4518=(($4512+($4517<<2))|0); + var $4519=$4518; + var $4520=$4519; + var $4521=HEAP32[(($4520)>>2)]; + var $4522=$2; + var $4523=(($4522+140)|0); + var $4524=HEAP32[(($4523)>>2)]; + var $4525=(($4521)|0) >= (($4524)|0); + if ($4525) { __label__ = 165; break; } else { __label__ = 166; break; } + case 165: + var $4527=$2; + var $4528=$2; + var $4529=(($4528)|0); + var $4530=HEAP32[(($4529)>>2)]; + _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)); + __label__ = 488; break; + case 166: + var $4532=$2; + var $4533=(($4532+64)|0); + var $4534=HEAP32[(($4533)>>2)]; + var $4535=$st; + var $4536=(($4535+4)|0); + var $4537=$4536; + var $4538=HEAP16[(($4537)>>1)]; + var $4539=(($4538)&65535); + var $4540=(($4534+($4539<<2))|0); + var $4541=$4540; + var $4542=$4541; + var $4543=HEAP32[(($4542)>>2)]; + var $4544=$2; + var $4545=(($4544+144)|0); + var $4546=HEAP32[(($4545)>>2)]; + var $4547=(($4543)>>>0) >= (($4546)>>>0); + if ($4547) { __label__ = 167; break; } else { __label__ = 168; break; } + case 167: + var $4549=$2; + var $4550=$2; + var $4551=(($4550)|0); + var $4552=HEAP32[(($4551)>>2)]; + var $4553=$2; + var $4554=(($4553+64)|0); + var $4555=HEAP32[(($4554)>>2)]; + var $4556=$st; + var $4557=(($4556+4)|0); + var $4558=$4557; + var $4559=HEAP16[(($4558)>>1)]; + var $4560=(($4559)&65535); + var $4561=(($4555+($4560<<2))|0); + var $4562=$4561; + var $4563=$4562; + var $4564=HEAP32[(($4563)>>2)]; + _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)); + __label__ = 488; break; + case 168: + var $4566=$2; + var $4567=$2; + var $4568=(($4567+64)|0); + var $4569=HEAP32[(($4568)>>2)]; + var $4570=$st; + var $4571=(($4570+2)|0); + var $4572=$4571; + var $4573=HEAP16[(($4572)>>1)]; + var $4574=(($4573)&65535); + var $4575=(($4569+($4574<<2))|0); + var $4576=$4575; + var $4577=$4576; + var $4578=HEAP32[(($4577)>>2)]; + var $4579=_prog_getedict($4566, $4578); + $ed2=$4579; + var $4580=$ed2; + var $4581=$4580; + var $4582=$2; + var $4583=(($4582+64)|0); + var $4584=HEAP32[(($4583)>>2)]; + var $4585=$st; + var $4586=(($4585+4)|0); + var $4587=$4586; + var $4588=HEAP16[(($4587)>>1)]; + var $4589=(($4588)&65535); + var $4590=(($4584+($4589<<2))|0); + var $4591=$4590; + var $4592=$4591; + var $4593=HEAP32[(($4592)>>2)]; + var $4594=(($4581+($4593<<2))|0); + var $4595=$4594; + var $4596=$4595; + var $4597=HEAP32[(($4596)>>2)]; + var $4598=$2; + var $4599=(($4598+64)|0); + var $4600=HEAP32[(($4599)>>2)]; + var $4601=$st; + var $4602=(($4601+6)|0); + var $4603=$4602; + var $4604=HEAP16[(($4603)>>1)]; + var $4605=(($4604)&65535); + var $4606=(($4600+($4605<<2))|0); + var $4607=$4606; + var $4608=$4607; + HEAP32[(($4608)>>2)]=$4597; + __label__ = 245; break; + case 169: + var $4610=$2; + var $4611=(($4610+64)|0); + var $4612=HEAP32[(($4611)>>2)]; + var $4613=$st; + var $4614=(($4613+2)|0); + var $4615=$4614; + var $4616=HEAP16[(($4615)>>1)]; + var $4617=(($4616)&65535); + var $4618=(($4612+($4617<<2))|0); + var $4619=$4618; + var $4620=$4619; + var $4621=HEAP32[(($4620)>>2)]; + var $4622=(($4621)|0) < 0; + if ($4622) { __label__ = 171; break; } else { __label__ = 170; break; } + case 170: + var $4624=$2; + var $4625=(($4624+64)|0); + var $4626=HEAP32[(($4625)>>2)]; + var $4627=$st; + var $4628=(($4627+2)|0); + var $4629=$4628; + var $4630=HEAP16[(($4629)>>1)]; + var $4631=(($4630)&65535); + var $4632=(($4626+($4631<<2))|0); + var $4633=$4632; + var $4634=$4633; + var $4635=HEAP32[(($4634)>>2)]; + var $4636=$2; + var $4637=(($4636+140)|0); + var $4638=HEAP32[(($4637)>>2)]; + var $4639=(($4635)|0) >= (($4638)|0); + if ($4639) { __label__ = 171; break; } else { __label__ = 172; break; } + case 171: + var $4641=$2; + var $4642=$2; + var $4643=(($4642)|0); + var $4644=HEAP32[(($4643)>>2)]; + _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)); + __label__ = 488; break; + case 172: + var $4646=$2; + var $4647=(($4646+64)|0); + var $4648=HEAP32[(($4647)>>2)]; + var $4649=$st; + var $4650=(($4649+4)|0); + var $4651=$4650; + var $4652=HEAP16[(($4651)>>1)]; + var $4653=(($4652)&65535); + var $4654=(($4648+($4653<<2))|0); + var $4655=$4654; + var $4656=$4655; + var $4657=HEAP32[(($4656)>>2)]; + var $4658=(($4657)|0) < 0; + if ($4658) { __label__ = 174; break; } else { __label__ = 173; break; } + case 173: + var $4660=$2; + var $4661=(($4660+64)|0); + var $4662=HEAP32[(($4661)>>2)]; + var $4663=$st; + var $4664=(($4663+4)|0); + var $4665=$4664; + var $4666=HEAP16[(($4665)>>1)]; + var $4667=(($4666)&65535); + var $4668=(($4662+($4667<<2))|0); + var $4669=$4668; + var $4670=$4669; + var $4671=HEAP32[(($4670)>>2)]; + var $4672=((($4671)+(3))|0); + var $4673=$2; + var $4674=(($4673+144)|0); + var $4675=HEAP32[(($4674)>>2)]; + var $4676=(($4672)>>>0) > (($4675)>>>0); + if ($4676) { __label__ = 174; break; } else { __label__ = 175; break; } + case 174: + var $4678=$2; + var $4679=$2; + var $4680=(($4679)|0); + var $4681=HEAP32[(($4680)>>2)]; + var $4682=$2; + var $4683=(($4682+64)|0); + var $4684=HEAP32[(($4683)>>2)]; + var $4685=$st; + var $4686=(($4685+4)|0); + var $4687=$4686; + var $4688=HEAP16[(($4687)>>1)]; + var $4689=(($4688)&65535); + var $4690=(($4684+($4689<<2))|0); + var $4691=$4690; + var $4692=$4691; + var $4693=HEAP32[(($4692)>>2)]; + var $4694=((($4693)+(2))|0); + _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)); + __label__ = 488; break; + case 175: + var $4696=$2; + var $4697=$2; + var $4698=(($4697+64)|0); + var $4699=HEAP32[(($4698)>>2)]; + var $4700=$st; + var $4701=(($4700+2)|0); + var $4702=$4701; + var $4703=HEAP16[(($4702)>>1)]; + var $4704=(($4703)&65535); + var $4705=(($4699+($4704<<2))|0); + var $4706=$4705; + var $4707=$4706; + var $4708=HEAP32[(($4707)>>2)]; + var $4709=_prog_getedict($4696, $4708); + $ed2=$4709; + var $4710=$ed2; + var $4711=$4710; + var $4712=$2; + var $4713=(($4712+64)|0); + var $4714=HEAP32[(($4713)>>2)]; + var $4715=$st; + var $4716=(($4715+4)|0); + var $4717=$4716; + var $4718=HEAP16[(($4717)>>1)]; + var $4719=(($4718)&65535); + var $4720=(($4714+($4719<<2))|0); + var $4721=$4720; + var $4722=$4721; + var $4723=HEAP32[(($4722)>>2)]; + var $4724=(($4711+($4723<<2))|0); + var $4725=$4724; + var $4726=$4725; + var $4727=(($4726)|0); + var $4728=HEAP32[(($4727)>>2)]; + var $4729=$2; + var $4730=(($4729+64)|0); + var $4731=HEAP32[(($4730)>>2)]; + var $4732=$st; + var $4733=(($4732+6)|0); + var $4734=$4733; + var $4735=HEAP16[(($4734)>>1)]; + var $4736=(($4735)&65535); + var $4737=(($4731+($4736<<2))|0); + var $4738=$4737; + var $4739=$4738; + var $4740=(($4739)|0); + HEAP32[(($4740)>>2)]=$4728; + var $4741=$ed2; + var $4742=$4741; + var $4743=$2; + var $4744=(($4743+64)|0); + var $4745=HEAP32[(($4744)>>2)]; + var $4746=$st; + var $4747=(($4746+4)|0); + var $4748=$4747; + var $4749=HEAP16[(($4748)>>1)]; + var $4750=(($4749)&65535); + var $4751=(($4745+($4750<<2))|0); + var $4752=$4751; + var $4753=$4752; + var $4754=HEAP32[(($4753)>>2)]; + var $4755=(($4742+($4754<<2))|0); + var $4756=$4755; + var $4757=$4756; + var $4758=(($4757+4)|0); + var $4759=HEAP32[(($4758)>>2)]; + var $4760=$2; + var $4761=(($4760+64)|0); + var $4762=HEAP32[(($4761)>>2)]; + var $4763=$st; + var $4764=(($4763+6)|0); + var $4765=$4764; + var $4766=HEAP16[(($4765)>>1)]; + var $4767=(($4766)&65535); + var $4768=(($4762+($4767<<2))|0); + var $4769=$4768; + var $4770=$4769; + var $4771=(($4770+4)|0); + HEAP32[(($4771)>>2)]=$4759; + var $4772=$ed2; + var $4773=$4772; + var $4774=$2; + var $4775=(($4774+64)|0); + var $4776=HEAP32[(($4775)>>2)]; + var $4777=$st; + var $4778=(($4777+4)|0); + var $4779=$4778; + var $4780=HEAP16[(($4779)>>1)]; + var $4781=(($4780)&65535); + var $4782=(($4776+($4781<<2))|0); + var $4783=$4782; + var $4784=$4783; + var $4785=HEAP32[(($4784)>>2)]; + var $4786=(($4773+($4785<<2))|0); + var $4787=$4786; + var $4788=$4787; + var $4789=(($4788+8)|0); + var $4790=HEAP32[(($4789)>>2)]; + var $4791=$2; + var $4792=(($4791+64)|0); + var $4793=HEAP32[(($4792)>>2)]; + var $4794=$st; + var $4795=(($4794+6)|0); + var $4796=$4795; + var $4797=HEAP16[(($4796)>>1)]; + var $4798=(($4797)&65535); + var $4799=(($4793+($4798<<2))|0); + var $4800=$4799; + var $4801=$4800; + var $4802=(($4801+8)|0); + HEAP32[(($4802)>>2)]=$4790; + __label__ = 245; break; + case 176: + var $4804=$2; + var $4805=(($4804+64)|0); + var $4806=HEAP32[(($4805)>>2)]; + var $4807=$st; + var $4808=(($4807+2)|0); + var $4809=$4808; + var $4810=HEAP16[(($4809)>>1)]; + var $4811=(($4810)&65535); + var $4812=(($4806+($4811<<2))|0); + var $4813=$4812; + var $4814=$4813; + var $4815=HEAP32[(($4814)>>2)]; + var $4816=(($4815)|0) < 0; + if ($4816) { __label__ = 178; break; } else { __label__ = 177; break; } + case 177: + var $4818=$2; + var $4819=(($4818+64)|0); + var $4820=HEAP32[(($4819)>>2)]; + var $4821=$st; + var $4822=(($4821+2)|0); + var $4823=$4822; + var $4824=HEAP16[(($4823)>>1)]; + var $4825=(($4824)&65535); + var $4826=(($4820+($4825<<2))|0); + var $4827=$4826; + var $4828=$4827; + var $4829=HEAP32[(($4828)>>2)]; + var $4830=$2; + var $4831=(($4830+140)|0); + var $4832=HEAP32[(($4831)>>2)]; + var $4833=(($4829)|0) >= (($4832)|0); + if ($4833) { __label__ = 178; break; } else { __label__ = 179; break; } + case 178: + var $4835=$2; + var $4836=$2; + var $4837=(($4836)|0); + var $4838=HEAP32[(($4837)>>2)]; + var $4839=$2; + var $4840=(($4839+64)|0); + var $4841=HEAP32[(($4840)>>2)]; + var $4842=$st; + var $4843=(($4842+2)|0); + var $4844=$4843; + var $4845=HEAP16[(($4844)>>1)]; + var $4846=(($4845)&65535); + var $4847=(($4841+($4846<<2))|0); + var $4848=$4847; + var $4849=$4848; + var $4850=HEAP32[(($4849)>>2)]; + _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)); + __label__ = 488; break; + case 179: + var $4852=$2; + var $4853=(($4852+64)|0); + var $4854=HEAP32[(($4853)>>2)]; + var $4855=$st; + var $4856=(($4855+4)|0); + var $4857=$4856; + var $4858=HEAP16[(($4857)>>1)]; + var $4859=(($4858)&65535); + var $4860=(($4854+($4859<<2))|0); + var $4861=$4860; + var $4862=$4861; + var $4863=HEAP32[(($4862)>>2)]; + var $4864=$2; + var $4865=(($4864+144)|0); + var $4866=HEAP32[(($4865)>>2)]; + var $4867=(($4863)>>>0) >= (($4866)>>>0); + if ($4867) { __label__ = 180; break; } else { __label__ = 181; break; } + case 180: + var $4869=$2; + var $4870=$2; + var $4871=(($4870)|0); + var $4872=HEAP32[(($4871)>>2)]; + var $4873=$2; + var $4874=(($4873+64)|0); + var $4875=HEAP32[(($4874)>>2)]; + var $4876=$st; + var $4877=(($4876+4)|0); + var $4878=$4877; + var $4879=HEAP16[(($4878)>>1)]; + var $4880=(($4879)&65535); + var $4881=(($4875+($4880<<2))|0); + var $4882=$4881; + var $4883=$4882; + var $4884=HEAP32[(($4883)>>2)]; + _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)); + __label__ = 488; break; + case 181: + var $4886=$2; + var $4887=$2; + var $4888=(($4887+64)|0); + var $4889=HEAP32[(($4888)>>2)]; + var $4890=$st; + var $4891=(($4890+2)|0); + var $4892=$4891; + var $4893=HEAP16[(($4892)>>1)]; + var $4894=(($4893)&65535); + var $4895=(($4889+($4894<<2))|0); + var $4896=$4895; + var $4897=$4896; + var $4898=HEAP32[(($4897)>>2)]; + var $4899=_prog_getedict($4886, $4898); + $ed2=$4899; + var $4900=$ed2; + var $4901=$4900; + var $4902=$2; + var $4903=(($4902+76)|0); + var $4904=HEAP32[(($4903)>>2)]; + var $4905=$4901; + var $4906=$4904; + var $4907=((($4905)-($4906))|0); + var $4908=((((($4907)|0))/(4))&-1); + var $4909=$2; + var $4910=(($4909+64)|0); + var $4911=HEAP32[(($4910)>>2)]; + var $4912=$st; + var $4913=(($4912+6)|0); + var $4914=$4913; + var $4915=HEAP16[(($4914)>>1)]; + var $4916=(($4915)&65535); + var $4917=(($4911+($4916<<2))|0); + var $4918=$4917; + var $4919=$4918; + HEAP32[(($4919)>>2)]=$4908; + var $4920=$2; + var $4921=(($4920+64)|0); + var $4922=HEAP32[(($4921)>>2)]; + var $4923=$st; + var $4924=(($4923+4)|0); + var $4925=$4924; + var $4926=HEAP16[(($4925)>>1)]; + var $4927=(($4926)&65535); + var $4928=(($4922+($4927<<2))|0); + var $4929=$4928; + var $4930=$4929; + var $4931=HEAP32[(($4930)>>2)]; + var $4932=$2; + var $4933=(($4932+64)|0); + var $4934=HEAP32[(($4933)>>2)]; + var $4935=$st; + var $4936=(($4935+6)|0); + var $4937=$4936; + var $4938=HEAP16[(($4937)>>1)]; + var $4939=(($4938)&65535); + var $4940=(($4934+($4939<<2))|0); + var $4941=$4940; + var $4942=$4941; + var $4943=HEAP32[(($4942)>>2)]; + var $4944=((($4943)+($4931))|0); + HEAP32[(($4942)>>2)]=$4944; + __label__ = 245; break; + case 182: + var $4946=$2; + var $4947=(($4946+64)|0); + var $4948=HEAP32[(($4947)>>2)]; + var $4949=$st; + var $4950=(($4949+2)|0); + var $4951=$4950; + var $4952=HEAP16[(($4951)>>1)]; + var $4953=(($4952)&65535); + var $4954=(($4948+($4953<<2))|0); + var $4955=$4954; + var $4956=$4955; + var $4957=HEAP32[(($4956)>>2)]; + var $4958=$2; + var $4959=(($4958+64)|0); + var $4960=HEAP32[(($4959)>>2)]; + var $4961=$st; + var $4962=(($4961+4)|0); + var $4963=$4962; + var $4964=HEAP16[(($4963)>>1)]; + var $4965=(($4964)&65535); + var $4966=(($4960+($4965<<2))|0); + var $4967=$4966; + var $4968=$4967; + HEAP32[(($4968)>>2)]=$4957; + __label__ = 245; break; + case 183: + var $4970=$2; + var $4971=(($4970+64)|0); + var $4972=HEAP32[(($4971)>>2)]; + var $4973=$st; + var $4974=(($4973+2)|0); + var $4975=$4974; + var $4976=HEAP16[(($4975)>>1)]; + var $4977=(($4976)&65535); + var $4978=(($4972+($4977<<2))|0); + var $4979=$4978; + var $4980=$4979; + var $4981=(($4980)|0); + var $4982=HEAP32[(($4981)>>2)]; + var $4983=$2; + var $4984=(($4983+64)|0); + var $4985=HEAP32[(($4984)>>2)]; + var $4986=$st; + var $4987=(($4986+4)|0); + var $4988=$4987; + var $4989=HEAP16[(($4988)>>1)]; + var $4990=(($4989)&65535); + var $4991=(($4985+($4990<<2))|0); + var $4992=$4991; + var $4993=$4992; + var $4994=(($4993)|0); + HEAP32[(($4994)>>2)]=$4982; + var $4995=$2; + var $4996=(($4995+64)|0); + var $4997=HEAP32[(($4996)>>2)]; + var $4998=$st; + var $4999=(($4998+2)|0); + var $5000=$4999; + var $5001=HEAP16[(($5000)>>1)]; + var $5002=(($5001)&65535); + var $5003=(($4997+($5002<<2))|0); + var $5004=$5003; + var $5005=$5004; + var $5006=(($5005+4)|0); + var $5007=HEAP32[(($5006)>>2)]; + var $5008=$2; + var $5009=(($5008+64)|0); + var $5010=HEAP32[(($5009)>>2)]; + var $5011=$st; + var $5012=(($5011+4)|0); + var $5013=$5012; + var $5014=HEAP16[(($5013)>>1)]; + var $5015=(($5014)&65535); + var $5016=(($5010+($5015<<2))|0); + var $5017=$5016; + var $5018=$5017; + var $5019=(($5018+4)|0); + HEAP32[(($5019)>>2)]=$5007; + var $5020=$2; + var $5021=(($5020+64)|0); + var $5022=HEAP32[(($5021)>>2)]; + var $5023=$st; + var $5024=(($5023+2)|0); + var $5025=$5024; + var $5026=HEAP16[(($5025)>>1)]; + var $5027=(($5026)&65535); + var $5028=(($5022+($5027<<2))|0); + var $5029=$5028; + var $5030=$5029; + var $5031=(($5030+8)|0); + var $5032=HEAP32[(($5031)>>2)]; + var $5033=$2; + var $5034=(($5033+64)|0); + var $5035=HEAP32[(($5034)>>2)]; + var $5036=$st; + var $5037=(($5036+4)|0); + var $5038=$5037; + var $5039=HEAP16[(($5038)>>1)]; + var $5040=(($5039)&65535); + var $5041=(($5035+($5040<<2))|0); + var $5042=$5041; + var $5043=$5042; + var $5044=(($5043+8)|0); + HEAP32[(($5044)>>2)]=$5032; + __label__ = 245; break; + case 184: + var $5046=$2; + var $5047=(($5046+64)|0); + var $5048=HEAP32[(($5047)>>2)]; + var $5049=$st; + var $5050=(($5049+4)|0); + var $5051=$5050; + var $5052=HEAP16[(($5051)>>1)]; + var $5053=(($5052)&65535); + var $5054=(($5048+($5053<<2))|0); + var $5055=$5054; + var $5056=$5055; + var $5057=HEAP32[(($5056)>>2)]; + var $5058=(($5057)|0) < 0; + if ($5058) { __label__ = 186; break; } else { __label__ = 185; break; } + case 185: + var $5060=$2; + var $5061=(($5060+64)|0); + var $5062=HEAP32[(($5061)>>2)]; + var $5063=$st; + var $5064=(($5063+4)|0); + var $5065=$5064; + var $5066=HEAP16[(($5065)>>1)]; + var $5067=(($5066)&65535); + var $5068=(($5062+($5067<<2))|0); + var $5069=$5068; + var $5070=$5069; + var $5071=HEAP32[(($5070)>>2)]; + var $5072=$2; + var $5073=(($5072+80)|0); + var $5074=HEAP32[(($5073)>>2)]; + var $5075=(($5071)>>>0) >= (($5074)>>>0); + if ($5075) { __label__ = 186; break; } else { __label__ = 187; break; } + case 186: + var $5077=$2; + var $5078=$2; + var $5079=(($5078)|0); + var $5080=HEAP32[(($5079)>>2)]; + var $5081=$2; + var $5082=(($5081+64)|0); + var $5083=HEAP32[(($5082)>>2)]; + var $5084=$st; + var $5085=(($5084+4)|0); + var $5086=$5085; + var $5087=HEAP16[(($5086)>>1)]; + var $5088=(($5087)&65535); + var $5089=(($5083+($5088<<2))|0); + var $5090=$5089; + var $5091=$5090; + var $5092=HEAP32[(($5091)>>2)]; + _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)); + __label__ = 488; break; + case 187: + var $5094=$2; + var $5095=(($5094+64)|0); + var $5096=HEAP32[(($5095)>>2)]; + var $5097=$st; + var $5098=(($5097+4)|0); + var $5099=$5098; + var $5100=HEAP16[(($5099)>>1)]; + var $5101=(($5100)&65535); + var $5102=(($5096+($5101<<2))|0); + var $5103=$5102; + var $5104=$5103; + var $5105=HEAP32[(($5104)>>2)]; + var $5106=$2; + var $5107=(($5106+144)|0); + var $5108=HEAP32[(($5107)>>2)]; + var $5109=(($5105)>>>0) < (($5108)>>>0); + if ($5109) { __label__ = 188; break; } else { __label__ = 190; break; } + case 188: + var $5111=$2; + var $5112=(($5111+148)|0); + var $5113=HEAP8[($5112)]; + var $5114=(($5113) & 1); + if ($5114) { __label__ = 190; break; } else { __label__ = 189; break; } + case 189: + var $5116=$2; + var $5117=$2; + var $5118=(($5117)|0); + var $5119=HEAP32[(($5118)>>2)]; + var $5120=$2; + var $5121=$2; + var $5122=$2; + var $5123=(($5122+64)|0); + var $5124=HEAP32[(($5123)>>2)]; + var $5125=$st; + var $5126=(($5125+4)|0); + var $5127=$5126; + var $5128=HEAP16[(($5127)>>1)]; + var $5129=(($5128)&65535); + var $5130=(($5124+($5129<<2))|0); + var $5131=$5130; + var $5132=$5131; + var $5133=HEAP32[(($5132)>>2)]; + var $5134=_prog_entfield($5121, $5133); + var $5135=(($5134+4)|0); + var $5136=HEAP32[(($5135)>>2)]; + var $5137=_prog_getstring($5120, $5136); + var $5138=$2; + var $5139=(($5138+64)|0); + var $5140=HEAP32[(($5139)>>2)]; + var $5141=$st; + var $5142=(($5141+4)|0); + var $5143=$5142; + var $5144=HEAP16[(($5143)>>1)]; + var $5145=(($5144)&65535); + var $5146=(($5140+($5145<<2))|0); + var $5147=$5146; + var $5148=$5147; + var $5149=HEAP32[(($5148)>>2)]; + _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)); + __label__ = 190; break; + case 190: + var $5151=$2; + var $5152=(($5151+76)|0); + var $5153=HEAP32[(($5152)>>2)]; + var $5154=$2; + var $5155=(($5154+64)|0); + var $5156=HEAP32[(($5155)>>2)]; + var $5157=$st; + var $5158=(($5157+4)|0); + var $5159=$5158; + var $5160=HEAP16[(($5159)>>1)]; + var $5161=(($5160)&65535); + var $5162=(($5156+($5161<<2))|0); + var $5163=$5162; + var $5164=$5163; + var $5165=HEAP32[(($5164)>>2)]; + var $5166=(($5153+($5165<<2))|0); + var $5167=$5166; + $ptr3=$5167; + var $5168=$2; + var $5169=(($5168+64)|0); + var $5170=HEAP32[(($5169)>>2)]; + var $5171=$st; + var $5172=(($5171+2)|0); + var $5173=$5172; + var $5174=HEAP16[(($5173)>>1)]; + var $5175=(($5174)&65535); + var $5176=(($5170+($5175<<2))|0); + var $5177=$5176; + var $5178=$5177; + var $5179=HEAP32[(($5178)>>2)]; + var $5180=$ptr3; + var $5181=$5180; + HEAP32[(($5181)>>2)]=$5179; + __label__ = 245; break; + case 191: + var $5183=$2; + var $5184=(($5183+64)|0); + var $5185=HEAP32[(($5184)>>2)]; + var $5186=$st; + var $5187=(($5186+4)|0); + var $5188=$5187; + var $5189=HEAP16[(($5188)>>1)]; + var $5190=(($5189)&65535); + var $5191=(($5185+($5190<<2))|0); + var $5192=$5191; + var $5193=$5192; + var $5194=HEAP32[(($5193)>>2)]; + var $5195=(($5194)|0) < 0; + if ($5195) { __label__ = 193; break; } else { __label__ = 192; break; } + case 192: + var $5197=$2; + var $5198=(($5197+64)|0); + var $5199=HEAP32[(($5198)>>2)]; + var $5200=$st; + var $5201=(($5200+4)|0); + var $5202=$5201; + var $5203=HEAP16[(($5202)>>1)]; + var $5204=(($5203)&65535); + var $5205=(($5199+($5204<<2))|0); + var $5206=$5205; + var $5207=$5206; + var $5208=HEAP32[(($5207)>>2)]; + var $5209=((($5208)+(2))|0); + var $5210=$2; + var $5211=(($5210+80)|0); + var $5212=HEAP32[(($5211)>>2)]; + var $5213=(($5209)>>>0) >= (($5212)>>>0); + if ($5213) { __label__ = 193; break; } else { __label__ = 194; break; } + case 193: + var $5215=$2; + var $5216=$2; + var $5217=(($5216)|0); + var $5218=HEAP32[(($5217)>>2)]; + var $5219=$2; + var $5220=(($5219+64)|0); + var $5221=HEAP32[(($5220)>>2)]; + var $5222=$st; + var $5223=(($5222+4)|0); + var $5224=$5223; + var $5225=HEAP16[(($5224)>>1)]; + var $5226=(($5225)&65535); + var $5227=(($5221+($5226<<2))|0); + var $5228=$5227; + var $5229=$5228; + var $5230=HEAP32[(($5229)>>2)]; + _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)); + __label__ = 488; break; + case 194: + var $5232=$2; + var $5233=(($5232+64)|0); + var $5234=HEAP32[(($5233)>>2)]; + var $5235=$st; + var $5236=(($5235+4)|0); + var $5237=$5236; + var $5238=HEAP16[(($5237)>>1)]; + var $5239=(($5238)&65535); + var $5240=(($5234+($5239<<2))|0); + var $5241=$5240; + var $5242=$5241; + var $5243=HEAP32[(($5242)>>2)]; + var $5244=$2; + var $5245=(($5244+144)|0); + var $5246=HEAP32[(($5245)>>2)]; + var $5247=(($5243)>>>0) < (($5246)>>>0); + if ($5247) { __label__ = 195; break; } else { __label__ = 197; break; } + case 195: + var $5249=$2; + var $5250=(($5249+148)|0); + var $5251=HEAP8[($5250)]; + var $5252=(($5251) & 1); + if ($5252) { __label__ = 197; break; } else { __label__ = 196; break; } + case 196: + var $5254=$2; + var $5255=$2; + var $5256=(($5255)|0); + var $5257=HEAP32[(($5256)>>2)]; + var $5258=$2; + var $5259=$2; + var $5260=$2; + var $5261=(($5260+64)|0); + var $5262=HEAP32[(($5261)>>2)]; + var $5263=$st; + var $5264=(($5263+4)|0); + var $5265=$5264; + var $5266=HEAP16[(($5265)>>1)]; + var $5267=(($5266)&65535); + var $5268=(($5262+($5267<<2))|0); + var $5269=$5268; + var $5270=$5269; + var $5271=HEAP32[(($5270)>>2)]; + var $5272=_prog_entfield($5259, $5271); + var $5273=(($5272+4)|0); + var $5274=HEAP32[(($5273)>>2)]; + var $5275=_prog_getstring($5258, $5274); + var $5276=$2; + var $5277=(($5276+64)|0); + var $5278=HEAP32[(($5277)>>2)]; + var $5279=$st; + var $5280=(($5279+4)|0); + var $5281=$5280; + var $5282=HEAP16[(($5281)>>1)]; + var $5283=(($5282)&65535); + var $5284=(($5278+($5283<<2))|0); + var $5285=$5284; + var $5286=$5285; + var $5287=HEAP32[(($5286)>>2)]; + _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)); + __label__ = 197; break; + case 197: + var $5289=$2; + var $5290=(($5289+76)|0); + var $5291=HEAP32[(($5290)>>2)]; + var $5292=$2; + var $5293=(($5292+64)|0); + var $5294=HEAP32[(($5293)>>2)]; + var $5295=$st; + var $5296=(($5295+4)|0); + var $5297=$5296; + var $5298=HEAP16[(($5297)>>1)]; + var $5299=(($5298)&65535); + var $5300=(($5294+($5299<<2))|0); + var $5301=$5300; + var $5302=$5301; + var $5303=HEAP32[(($5302)>>2)]; + var $5304=(($5291+($5303<<2))|0); + var $5305=$5304; + $ptr3=$5305; + var $5306=$2; + var $5307=(($5306+64)|0); + var $5308=HEAP32[(($5307)>>2)]; + var $5309=$st; + var $5310=(($5309+2)|0); + var $5311=$5310; + var $5312=HEAP16[(($5311)>>1)]; + var $5313=(($5312)&65535); + var $5314=(($5308+($5313<<2))|0); + var $5315=$5314; + var $5316=$5315; + var $5317=(($5316)|0); + var $5318=HEAP32[(($5317)>>2)]; + var $5319=$ptr3; + var $5320=$5319; + var $5321=(($5320)|0); + HEAP32[(($5321)>>2)]=$5318; + var $5322=$2; + var $5323=(($5322+64)|0); + var $5324=HEAP32[(($5323)>>2)]; + var $5325=$st; + var $5326=(($5325+2)|0); + var $5327=$5326; + var $5328=HEAP16[(($5327)>>1)]; + var $5329=(($5328)&65535); + var $5330=(($5324+($5329<<2))|0); + var $5331=$5330; + var $5332=$5331; + var $5333=(($5332+4)|0); + var $5334=HEAP32[(($5333)>>2)]; + var $5335=$ptr3; + var $5336=$5335; + var $5337=(($5336+4)|0); + HEAP32[(($5337)>>2)]=$5334; + var $5338=$2; + var $5339=(($5338+64)|0); + var $5340=HEAP32[(($5339)>>2)]; + var $5341=$st; + var $5342=(($5341+2)|0); + var $5343=$5342; + var $5344=HEAP16[(($5343)>>1)]; + var $5345=(($5344)&65535); + var $5346=(($5340+($5345<<2))|0); + var $5347=$5346; + var $5348=$5347; + var $5349=(($5348+8)|0); + var $5350=HEAP32[(($5349)>>2)]; + var $5351=$ptr3; + var $5352=$5351; + var $5353=(($5352+8)|0); + HEAP32[(($5353)>>2)]=$5350; + __label__ = 245; break; + case 198: + var $5355=$2; + var $5356=(($5355+64)|0); + var $5357=HEAP32[(($5356)>>2)]; + var $5358=$st; + var $5359=(($5358+2)|0); + var $5360=$5359; + var $5361=HEAP16[(($5360)>>1)]; + var $5362=(($5361)&65535); + var $5363=(($5357+($5362<<2))|0); + var $5364=$5363; + var $5365=$5364; + var $5366=HEAP32[(($5365)>>2)]; + var $5367=$5366 & 2147483647; + var $5368=(($5367)|0)!=0; + var $5369=$5368 ^ 1; + var $5370=(($5369)&1); + var $5371=(($5370)|0); + var $5372=$2; + var $5373=(($5372+64)|0); + var $5374=HEAP32[(($5373)>>2)]; + var $5375=$st; + var $5376=(($5375+6)|0); + var $5377=$5376; + var $5378=HEAP16[(($5377)>>1)]; + var $5379=(($5378)&65535); + var $5380=(($5374+($5379<<2))|0); + var $5381=$5380; + var $5382=$5381; + HEAPF32[(($5382)>>2)]=$5371; + __label__ = 245; break; + case 199: + var $5384=$2; + var $5385=(($5384+64)|0); + var $5386=HEAP32[(($5385)>>2)]; + var $5387=$st; + var $5388=(($5387+2)|0); + var $5389=$5388; + var $5390=HEAP16[(($5389)>>1)]; + var $5391=(($5390)&65535); + var $5392=(($5386+($5391<<2))|0); + var $5393=$5392; + var $5394=$5393; + var $5395=(($5394)|0); + var $5396=HEAPF32[(($5395)>>2)]; + var $5397=$5396 != 0; + if ($5397) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 200; break; } + case 200: + var $5399=$2; + var $5400=(($5399+64)|0); + var $5401=HEAP32[(($5400)>>2)]; + var $5402=$st; + var $5403=(($5402+2)|0); + var $5404=$5403; + var $5405=HEAP16[(($5404)>>1)]; + var $5406=(($5405)&65535); + var $5407=(($5401+($5406<<2))|0); + var $5408=$5407; + var $5409=$5408; + var $5410=(($5409+4)|0); + var $5411=HEAPF32[(($5410)>>2)]; + var $5412=$5411 != 0; + if ($5412) { var $5430 = 0;__label__ = 202; break; } else { __label__ = 201; break; } + case 201: + var $5414=$2; + var $5415=(($5414+64)|0); + var $5416=HEAP32[(($5415)>>2)]; + var $5417=$st; + var $5418=(($5417+2)|0); + var $5419=$5418; + var $5420=HEAP16[(($5419)>>1)]; + var $5421=(($5420)&65535); + var $5422=(($5416+($5421<<2))|0); + var $5423=$5422; + var $5424=$5423; + var $5425=(($5424+8)|0); + var $5426=HEAPF32[(($5425)>>2)]; + var $5427=$5426 != 0; + var $5428=$5427 ^ 1; + var $5430 = $5428;__label__ = 202; break; + case 202: + var $5430; + var $5431=(($5430)&1); + var $5432=(($5431)|0); + var $5433=$2; + var $5434=(($5433+64)|0); + var $5435=HEAP32[(($5434)>>2)]; + var $5436=$st; + var $5437=(($5436+6)|0); + var $5438=$5437; + var $5439=HEAP16[(($5438)>>1)]; + var $5440=(($5439)&65535); + var $5441=(($5435+($5440<<2))|0); + var $5442=$5441; + var $5443=$5442; + HEAPF32[(($5443)>>2)]=$5432; + __label__ = 245; break; + case 203: + var $5445=$2; + var $5446=(($5445+64)|0); + var $5447=HEAP32[(($5446)>>2)]; + var $5448=$st; + var $5449=(($5448+2)|0); + var $5450=$5449; + var $5451=HEAP16[(($5450)>>1)]; + var $5452=(($5451)&65535); + var $5453=(($5447+($5452<<2))|0); + var $5454=$5453; + var $5455=$5454; + var $5456=HEAP32[(($5455)>>2)]; + var $5457=(($5456)|0)!=0; + if ($5457) { __label__ = 204; break; } else { var $5477 = 1;__label__ = 205; break; } + case 204: + var $5459=$2; + var $5460=$2; + var $5461=(($5460+64)|0); + var $5462=HEAP32[(($5461)>>2)]; + var $5463=$st; + var $5464=(($5463+2)|0); + var $5465=$5464; + var $5466=HEAP16[(($5465)>>1)]; + var $5467=(($5466)&65535); + var $5468=(($5462+($5467<<2))|0); + var $5469=$5468; + var $5470=$5469; + var $5471=HEAP32[(($5470)>>2)]; + var $5472=_prog_getstring($5459, $5471); + var $5473=HEAP8[($5472)]; + var $5474=(($5473 << 24) >> 24)!=0; + var $5475=$5474 ^ 1; + var $5477 = $5475;__label__ = 205; break; + case 205: + var $5477; + var $5478=(($5477)&1); + var $5479=(($5478)|0); + var $5480=$2; + var $5481=(($5480+64)|0); + var $5482=HEAP32[(($5481)>>2)]; + var $5483=$st; + var $5484=(($5483+6)|0); + var $5485=$5484; + var $5486=HEAP16[(($5485)>>1)]; + var $5487=(($5486)&65535); + var $5488=(($5482+($5487<<2))|0); + var $5489=$5488; + var $5490=$5489; + HEAPF32[(($5490)>>2)]=$5479; + __label__ = 245; break; + case 206: + var $5492=$2; + var $5493=(($5492+64)|0); + var $5494=HEAP32[(($5493)>>2)]; + var $5495=$st; + var $5496=(($5495+2)|0); + var $5497=$5496; + var $5498=HEAP16[(($5497)>>1)]; + var $5499=(($5498)&65535); + var $5500=(($5494+($5499<<2))|0); + var $5501=$5500; + var $5502=$5501; + var $5503=HEAP32[(($5502)>>2)]; + var $5504=(($5503)|0)==0; + var $5505=(($5504)&1); + var $5506=(($5505)|0); + var $5507=$2; + var $5508=(($5507+64)|0); + var $5509=HEAP32[(($5508)>>2)]; + var $5510=$st; + var $5511=(($5510+6)|0); + var $5512=$5511; + var $5513=HEAP16[(($5512)>>1)]; + var $5514=(($5513)&65535); + var $5515=(($5509+($5514<<2))|0); + var $5516=$5515; + var $5517=$5516; + HEAPF32[(($5517)>>2)]=$5506; + __label__ = 245; break; + case 207: + var $5519=$2; + var $5520=(($5519+64)|0); + var $5521=HEAP32[(($5520)>>2)]; + var $5522=$st; + var $5523=(($5522+2)|0); + var $5524=$5523; + var $5525=HEAP16[(($5524)>>1)]; + var $5526=(($5525)&65535); + var $5527=(($5521+($5526<<2))|0); + var $5528=$5527; + var $5529=$5528; + var $5530=HEAP32[(($5529)>>2)]; + var $5531=(($5530)|0)!=0; + var $5532=$5531 ^ 1; + var $5533=(($5532)&1); + var $5534=(($5533)|0); + var $5535=$2; + var $5536=(($5535+64)|0); + var $5537=HEAP32[(($5536)>>2)]; + var $5538=$st; + var $5539=(($5538+6)|0); + var $5540=$5539; + var $5541=HEAP16[(($5540)>>1)]; + var $5542=(($5541)&65535); + var $5543=(($5537+($5542<<2))|0); + var $5544=$5543; + var $5545=$5544; + HEAPF32[(($5545)>>2)]=$5534; + __label__ = 245; break; + case 208: + var $5547=$2; + var $5548=(($5547+64)|0); + var $5549=HEAP32[(($5548)>>2)]; + var $5550=$st; + var $5551=(($5550+2)|0); + var $5552=$5551; + var $5553=HEAP16[(($5552)>>1)]; + var $5554=(($5553)&65535); + var $5555=(($5549+($5554<<2))|0); + var $5556=$5555; + var $5557=$5556; + var $5558=HEAP32[(($5557)>>2)]; + var $5559=$5558 & 2147483647; + var $5560=(($5559)|0)!=0; + if ($5560) { __label__ = 209; break; } else { __label__ = 212; break; } + case 209: + var $5562=$st; + var $5563=(($5562+4)|0); + var $5564=$5563; + var $5565=HEAP16[(($5564)>>1)]; + var $5566=(($5565 << 16) >> 16); + var $5567=((($5566)-(1))|0); + var $5568=$st; + var $5569=(($5568+($5567<<3))|0); + $st=$5569; + var $5570=$jumpcount; + var $5571=((($5570)+(1))|0); + $jumpcount=$5571; + var $5572=$5; + var $5573=(($5571)|0) >= (($5572)|0); + if ($5573) { __label__ = 210; break; } else { __label__ = 211; break; } + case 210: + var $5575=$2; + var $5576=$2; + var $5577=(($5576)|0); + var $5578=HEAP32[(($5577)>>2)]; + var $5579=$jumpcount; + _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)); + __label__ = 211; break; + case 211: + __label__ = 212; break; + case 212: + __label__ = 245; break; + case 213: + var $5583=$2; + var $5584=(($5583+64)|0); + var $5585=HEAP32[(($5584)>>2)]; + var $5586=$st; + var $5587=(($5586+2)|0); + var $5588=$5587; + var $5589=HEAP16[(($5588)>>1)]; + var $5590=(($5589)&65535); + var $5591=(($5585+($5590<<2))|0); + var $5592=$5591; + var $5593=$5592; + var $5594=HEAP32[(($5593)>>2)]; + var $5595=$5594 & 2147483647; + var $5596=(($5595)|0)!=0; + if ($5596) { __label__ = 217; break; } else { __label__ = 214; break; } + case 214: + var $5598=$st; + var $5599=(($5598+4)|0); + var $5600=$5599; + var $5601=HEAP16[(($5600)>>1)]; + var $5602=(($5601 << 16) >> 16); + var $5603=((($5602)-(1))|0); + var $5604=$st; + var $5605=(($5604+($5603<<3))|0); + $st=$5605; + var $5606=$jumpcount; + var $5607=((($5606)+(1))|0); + $jumpcount=$5607; + var $5608=$5; + var $5609=(($5607)|0) >= (($5608)|0); + if ($5609) { __label__ = 215; break; } else { __label__ = 216; break; } + case 215: + var $5611=$2; + var $5612=$2; + var $5613=(($5612)|0); + var $5614=HEAP32[(($5613)>>2)]; + var $5615=$jumpcount; + _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)); + __label__ = 216; break; + case 216: + __label__ = 217; break; + case 217: + __label__ = 245; break; + case 218: + var $5619=$st; + var $5620=(($5619)|0); + var $5621=HEAP16[(($5620)>>1)]; + var $5622=(($5621)&65535); + var $5623=((($5622)-(51))|0); + var $5624=$2; + var $5625=(($5624+184)|0); + HEAP32[(($5625)>>2)]=$5623; + var $5626=$2; + var $5627=(($5626+64)|0); + var $5628=HEAP32[(($5627)>>2)]; + var $5629=$st; + var $5630=(($5629+2)|0); + var $5631=$5630; + var $5632=HEAP16[(($5631)>>1)]; + var $5633=(($5632)&65535); + var $5634=(($5628+($5633<<2))|0); + var $5635=$5634; + var $5636=$5635; + var $5637=HEAP32[(($5636)>>2)]; + var $5638=(($5637)|0)!=0; + if ($5638) { __label__ = 220; break; } else { __label__ = 219; break; } + case 219: + var $5640=$2; + var $5641=$2; + var $5642=(($5641)|0); + var $5643=HEAP32[(($5642)>>2)]; + _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)); + __label__ = 220; break; + case 220: + var $5645=$2; + var $5646=(($5645+64)|0); + var $5647=HEAP32[(($5646)>>2)]; + var $5648=$st; + var $5649=(($5648+2)|0); + var $5650=$5649; + var $5651=HEAP16[(($5650)>>1)]; + var $5652=(($5651)&65535); + var $5653=(($5647+($5652<<2))|0); + var $5654=$5653; + var $5655=$5654; + var $5656=HEAP32[(($5655)>>2)]; + var $5657=(($5656)|0)!=0; + if ($5657) { __label__ = 221; break; } else { __label__ = 222; break; } + case 221: + var $5659=$2; + var $5660=(($5659+64)|0); + var $5661=HEAP32[(($5660)>>2)]; + var $5662=$st; + var $5663=(($5662+2)|0); + var $5664=$5663; + var $5665=HEAP16[(($5664)>>1)]; + var $5666=(($5665)&65535); + var $5667=(($5661+($5666<<2))|0); + var $5668=$5667; + var $5669=$5668; + var $5670=HEAP32[(($5669)>>2)]; + var $5671=$2; + var $5672=(($5671+44)|0); + var $5673=HEAP32[(($5672)>>2)]; + var $5674=(($5670)>>>0) >= (($5673)>>>0); + if ($5674) { __label__ = 222; break; } else { __label__ = 223; break; } + case 222: + var $5676=$2; + var $5677=$2; + var $5678=(($5677)|0); + var $5679=HEAP32[(($5678)>>2)]; + _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)); + __label__ = 488; break; + case 223: + var $5681=$2; + var $5682=(($5681+64)|0); + var $5683=HEAP32[(($5682)>>2)]; + var $5684=$st; + var $5685=(($5684+2)|0); + var $5686=$5685; + var $5687=HEAP16[(($5686)>>1)]; + var $5688=(($5687)&65535); + var $5689=(($5683+($5688<<2))|0); + var $5690=$5689; + var $5691=$5690; + var $5692=HEAP32[(($5691)>>2)]; + var $5693=$2; + var $5694=(($5693+40)|0); + var $5695=HEAP32[(($5694)>>2)]; + var $5696=(($5695+($5692)*(36))|0); + $newf1=$5696; + var $5697=$newf1; + var $5698=(($5697+12)|0); + var $5699=HEAP32[(($5698)>>2)]; + var $5700=((($5699)+(1))|0); + HEAP32[(($5698)>>2)]=$5700; + var $5701=$st; + var $5702=$2; + var $5703=(($5702+4)|0); + var $5704=HEAP32[(($5703)>>2)]; + var $5705=$5701; + var $5706=$5704; + var $5707=((($5705)-($5706))|0); + var $5708=((((($5707)|0))/(8))&-1); + var $5709=((($5708)+(1))|0); + var $5710=$2; + var $5711=(($5710+176)|0); + HEAP32[(($5711)>>2)]=$5709; + var $5712=$newf1; + var $5713=(($5712)|0); + var $5714=HEAP32[(($5713)>>2)]; + var $5715=(($5714)|0) < 0; + if ($5715) { __label__ = 224; break; } else { __label__ = 229; break; } + case 224: + var $5717=$newf1; + var $5718=(($5717)|0); + var $5719=HEAP32[(($5718)>>2)]; + var $5720=(((-$5719))|0); + $builtinnumber4=$5720; + var $5721=$builtinnumber4; + var $5722=$2; + var $5723=(($5722+132)|0); + var $5724=HEAP32[(($5723)>>2)]; + var $5725=(($5721)>>>0) < (($5724)>>>0); + if ($5725) { __label__ = 225; break; } else { __label__ = 227; break; } + case 225: + var $5727=$builtinnumber4; + var $5728=$2; + var $5729=(($5728+128)|0); + var $5730=HEAP32[(($5729)>>2)]; + var $5731=(($5730+($5727<<2))|0); + var $5732=HEAP32[(($5731)>>2)]; + var $5733=(($5732)|0)!=0; + if ($5733) { __label__ = 226; break; } else { __label__ = 227; break; } + case 226: + var $5735=$builtinnumber4; + var $5736=$2; + var $5737=(($5736+128)|0); + var $5738=HEAP32[(($5737)>>2)]; + var $5739=(($5738+($5735<<2))|0); + var $5740=HEAP32[(($5739)>>2)]; + var $5741=$2; + var $5742=FUNCTION_TABLE[$5740]($5741); + __label__ = 228; break; + case 227: + var $5744=$2; + var $5745=$builtinnumber4; + var $5746=$2; + var $5747=(($5746)|0); + var $5748=HEAP32[(($5747)>>2)]; + _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)); + __label__ = 228; break; + case 228: + __label__ = 230; break; + case 229: + var $5751=$2; + var $5752=(($5751+4)|0); + var $5753=HEAP32[(($5752)>>2)]; + var $5754=$2; + var $5755=$newf1; + var $5756=_prog_enterfunction($5754, $5755); + var $5757=(($5753+($5756<<3))|0); + var $5758=((($5757)-(8))|0); + $st=$5758; + __label__ = 230; break; + case 230: + var $5760=$2; + var $5761=(($5760+112)|0); + var $5762=HEAP32[(($5761)>>2)]; + var $5763=(($5762)|0)!=0; + if ($5763) { __label__ = 231; break; } else { __label__ = 232; break; } + case 231: + __label__ = 488; break; + case 232: + __label__ = 245; break; + case 233: + var $5767=$2; + var $5768=$2; + var $5769=(($5768)|0); + var $5770=HEAP32[(($5769)>>2)]; + _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)); + __label__ = 245; break; + case 234: + var $5772=$st; + var $5773=(($5772+2)|0); + var $5774=$5773; + var $5775=HEAP16[(($5774)>>1)]; + var $5776=(($5775 << 16) >> 16); + var $5777=((($5776)-(1))|0); + var $5778=$st; + var $5779=(($5778+($5777<<3))|0); + $st=$5779; + var $5780=$jumpcount; + var $5781=((($5780)+(1))|0); + $jumpcount=$5781; + var $5782=(($5781)|0)==10000000; + if ($5782) { __label__ = 235; break; } else { __label__ = 236; break; } + case 235: + var $5784=$2; + var $5785=$2; + var $5786=(($5785)|0); + var $5787=HEAP32[(($5786)>>2)]; + var $5788=$jumpcount; + _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)); + __label__ = 236; break; + case 236: + __label__ = 245; break; + case 237: + var $5791=$2; + var $5792=(($5791+64)|0); + var $5793=HEAP32[(($5792)>>2)]; + var $5794=$st; + var $5795=(($5794+2)|0); + var $5796=$5795; + var $5797=HEAP16[(($5796)>>1)]; + var $5798=(($5797)&65535); + var $5799=(($5793+($5798<<2))|0); + var $5800=$5799; + var $5801=$5800; + var $5802=HEAP32[(($5801)>>2)]; + var $5803=$5802 & 2147483647; + var $5804=(($5803)|0)!=0; + if ($5804) { __label__ = 238; break; } else { var $5821 = 0;__label__ = 239; break; } + case 238: + var $5806=$2; + var $5807=(($5806+64)|0); + var $5808=HEAP32[(($5807)>>2)]; + var $5809=$st; + var $5810=(($5809+4)|0); + var $5811=$5810; + var $5812=HEAP16[(($5811)>>1)]; + var $5813=(($5812)&65535); + var $5814=(($5808+($5813<<2))|0); + var $5815=$5814; + var $5816=$5815; + var $5817=HEAP32[(($5816)>>2)]; + var $5818=$5817 & 2147483647; + var $5819=(($5818)|0)!=0; + var $5821 = $5819;__label__ = 239; break; + case 239: + var $5821; + var $5822=(($5821)&1); + var $5823=(($5822)|0); + var $5824=$2; + var $5825=(($5824+64)|0); + var $5826=HEAP32[(($5825)>>2)]; + var $5827=$st; + var $5828=(($5827+6)|0); + var $5829=$5828; + var $5830=HEAP16[(($5829)>>1)]; + var $5831=(($5830)&65535); + var $5832=(($5826+($5831<<2))|0); + var $5833=$5832; + var $5834=$5833; + HEAPF32[(($5834)>>2)]=$5823; + __label__ = 245; break; + case 240: + var $5836=$2; + var $5837=(($5836+64)|0); + var $5838=HEAP32[(($5837)>>2)]; + var $5839=$st; + var $5840=(($5839+2)|0); + var $5841=$5840; + var $5842=HEAP16[(($5841)>>1)]; + var $5843=(($5842)&65535); + var $5844=(($5838+($5843<<2))|0); + var $5845=$5844; + var $5846=$5845; + var $5847=HEAP32[(($5846)>>2)]; + var $5848=$5847 & 2147483647; + var $5849=(($5848)|0)!=0; + if ($5849) { var $5866 = 1;__label__ = 242; break; } else { __label__ = 241; break; } + case 241: + var $5851=$2; + var $5852=(($5851+64)|0); + var $5853=HEAP32[(($5852)>>2)]; + var $5854=$st; + var $5855=(($5854+4)|0); + var $5856=$5855; + var $5857=HEAP16[(($5856)>>1)]; + var $5858=(($5857)&65535); + var $5859=(($5853+($5858<<2))|0); + var $5860=$5859; + var $5861=$5860; + var $5862=HEAP32[(($5861)>>2)]; + var $5863=$5862 & 2147483647; + var $5864=(($5863)|0)!=0; + var $5866 = $5864;__label__ = 242; break; + case 242: + var $5866; + var $5867=(($5866)&1); + var $5868=(($5867)|0); + var $5869=$2; + var $5870=(($5869+64)|0); + var $5871=HEAP32[(($5870)>>2)]; + var $5872=$st; + var $5873=(($5872+6)|0); + var $5874=$5873; + var $5875=HEAP16[(($5874)>>1)]; + var $5876=(($5875)&65535); + var $5877=(($5871+($5876<<2))|0); + var $5878=$5877; + var $5879=$5878; + HEAPF32[(($5879)>>2)]=$5868; + __label__ = 245; break; + case 243: + var $5881=$2; + var $5882=(($5881+64)|0); + var $5883=HEAP32[(($5882)>>2)]; + var $5884=$st; + var $5885=(($5884+2)|0); + var $5886=$5885; + var $5887=HEAP16[(($5886)>>1)]; + var $5888=(($5887)&65535); + var $5889=(($5883+($5888<<2))|0); + var $5890=$5889; + var $5891=$5890; + var $5892=HEAPF32[(($5891)>>2)]; + var $5893=(($5892)&-1); + var $5894=$2; + var $5895=(($5894+64)|0); + var $5896=HEAP32[(($5895)>>2)]; + var $5897=$st; + var $5898=(($5897+4)|0); + var $5899=$5898; + var $5900=HEAP16[(($5899)>>1)]; + var $5901=(($5900)&65535); + var $5902=(($5896+($5901<<2))|0); + var $5903=$5902; + var $5904=$5903; + var $5905=HEAPF32[(($5904)>>2)]; + var $5906=(($5905)&-1); + var $5907=$5893 & $5906; + var $5908=(($5907)|0); + var $5909=$2; + var $5910=(($5909+64)|0); + var $5911=HEAP32[(($5910)>>2)]; + var $5912=$st; + var $5913=(($5912+6)|0); + var $5914=$5913; + var $5915=HEAP16[(($5914)>>1)]; + var $5916=(($5915)&65535); + var $5917=(($5911+($5916<<2))|0); + var $5918=$5917; + var $5919=$5918; + HEAPF32[(($5919)>>2)]=$5908; + __label__ = 245; break; + case 244: + var $5921=$2; + var $5922=(($5921+64)|0); + var $5923=HEAP32[(($5922)>>2)]; + var $5924=$st; + var $5925=(($5924+2)|0); + var $5926=$5925; + var $5927=HEAP16[(($5926)>>1)]; + var $5928=(($5927)&65535); + var $5929=(($5923+($5928<<2))|0); + var $5930=$5929; + var $5931=$5930; + var $5932=HEAPF32[(($5931)>>2)]; + var $5933=(($5932)&-1); + var $5934=$2; + var $5935=(($5934+64)|0); + var $5936=HEAP32[(($5935)>>2)]; + var $5937=$st; + var $5938=(($5937+4)|0); + var $5939=$5938; + var $5940=HEAP16[(($5939)>>1)]; + var $5941=(($5940)&65535); + var $5942=(($5936+($5941<<2))|0); + var $5943=$5942; + var $5944=$5943; + var $5945=HEAPF32[(($5944)>>2)]; + var $5946=(($5945)&-1); + var $5947=$5933 | $5946; + var $5948=(($5947)|0); + var $5949=$2; + var $5950=(($5949+64)|0); + var $5951=HEAP32[(($5950)>>2)]; + var $5952=$st; + var $5953=(($5952+6)|0); + var $5954=$5953; + var $5955=HEAP16[(($5954)>>1)]; + var $5956=(($5955)&65535); + var $5957=(($5951+($5956<<2))|0); + var $5958=$5957; + var $5959=$5958; + HEAPF32[(($5959)>>2)]=$5948; + __label__ = 245; break; + case 245: + __label__ = 126; break; + case 246: + __label__ = 247; break; + case 247: + var $5963=$st; + var $5964=(($5963+8)|0); + $st=$5964; + var $5965=$st; + var $5966=$2; + var $5967=(($5966+4)|0); + var $5968=HEAP32[(($5967)>>2)]; + var $5969=$5965; + var $5970=$5968; + var $5971=((($5969)-($5970))|0); + var $5972=((((($5971)|0))/(8))&-1); + var $5973=$2; + var $5974=(($5973+116)|0); + var $5975=HEAP32[(($5974)>>2)]; + var $5976=(($5975+($5972<<2))|0); + var $5977=HEAP32[(($5976)>>2)]; + var $5978=((($5977)+(1))|0); + HEAP32[(($5976)>>2)]=$5978; + var $5979=$st; + var $5980=(($5979)|0); + var $5981=HEAP16[(($5980)>>1)]; + var $5982=(($5981)&65535); + if ((($5982)|0) == 0 || (($5982)|0) == 43) { + __label__ = 249; break; + } + else if ((($5982)|0) == 1) { + __label__ = 252; break; + } + else if ((($5982)|0) == 2) { + __label__ = 253; break; + } + else if ((($5982)|0) == 3) { + __label__ = 254; break; + } + else if ((($5982)|0) == 4) { + __label__ = 255; break; + } + else if ((($5982)|0) == 5) { + __label__ = 256; break; + } + else if ((($5982)|0) == 6) { + __label__ = 260; break; + } + else if ((($5982)|0) == 7) { + __label__ = 261; break; + } + else if ((($5982)|0) == 8) { + __label__ = 262; break; + } + else if ((($5982)|0) == 9) { + __label__ = 263; break; + } + else if ((($5982)|0) == 10) { + __label__ = 264; break; + } + else if ((($5982)|0) == 11) { + __label__ = 265; break; + } + else if ((($5982)|0) == 12) { + __label__ = 269; break; + } + else if ((($5982)|0) == 13) { + __label__ = 270; break; + } + else if ((($5982)|0) == 14) { + __label__ = 271; break; + } + else if ((($5982)|0) == 15) { + __label__ = 272; break; + } + else if ((($5982)|0) == 16) { + __label__ = 273; break; + } + else if ((($5982)|0) == 17) { + __label__ = 277; break; + } + else if ((($5982)|0) == 18) { + __label__ = 278; break; + } + else if ((($5982)|0) == 19) { + __label__ = 279; break; + } + else if ((($5982)|0) == 20) { + __label__ = 280; break; + } + else if ((($5982)|0) == 21) { + __label__ = 281; break; + } + else if ((($5982)|0) == 22) { + __label__ = 282; break; + } + else if ((($5982)|0) == 23) { + __label__ = 283; break; + } + else if ((($5982)|0) == 24 || (($5982)|0) == 26 || (($5982)|0) == 28 || (($5982)|0) == 27 || (($5982)|0) == 29) { + __label__ = 284; break; + } + else if ((($5982)|0) == 25) { + __label__ = 290; break; + } + else if ((($5982)|0) == 30) { + __label__ = 297; break; + } + else if ((($5982)|0) == 31 || (($5982)|0) == 33 || (($5982)|0) == 34 || (($5982)|0) == 35 || (($5982)|0) == 36) { + __label__ = 303; break; + } + else if ((($5982)|0) == 32) { + __label__ = 304; break; + } + else if ((($5982)|0) == 37 || (($5982)|0) == 39 || (($5982)|0) == 40 || (($5982)|0) == 41 || (($5982)|0) == 42) { + __label__ = 305; break; + } + else if ((($5982)|0) == 38) { + __label__ = 312; break; + } + else if ((($5982)|0) == 44) { + __label__ = 319; break; + } + else if ((($5982)|0) == 45) { + __label__ = 320; break; + } + else if ((($5982)|0) == 46) { + __label__ = 324; break; + } + else if ((($5982)|0) == 47) { + __label__ = 327; break; + } + else if ((($5982)|0) == 48) { + __label__ = 328; break; + } + else if ((($5982)|0) == 49) { + __label__ = 329; break; + } + else if ((($5982)|0) == 50) { + __label__ = 334; break; + } + 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) { + __label__ = 339; break; + } + else if ((($5982)|0) == 60) { + __label__ = 354; break; + } + else if ((($5982)|0) == 61) { + __label__ = 355; break; + } + else if ((($5982)|0) == 62) { + __label__ = 358; break; + } + else if ((($5982)|0) == 63) { + __label__ = 361; break; + } + else if ((($5982)|0) == 64) { + __label__ = 364; break; + } + else if ((($5982)|0) == 65) { + __label__ = 365; break; + } + else { + __label__ = 248; break; + } + + case 248: + var $5984=$2; + var $5985=$2; + var $5986=(($5985)|0); + var $5987=HEAP32[(($5986)>>2)]; + _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)); + __label__ = 488; break; + case 249: + var $5989=$2; + var $5990=(($5989+64)|0); + var $5991=HEAP32[(($5990)>>2)]; + var $5992=$st; + var $5993=(($5992+2)|0); + var $5994=$5993; + var $5995=HEAP16[(($5994)>>1)]; + var $5996=(($5995)&65535); + var $5997=(($5991+($5996<<2))|0); + var $5998=$5997; + var $5999=$5998; + var $6000=(($5999)|0); + var $6001=HEAP32[(($6000)>>2)]; + var $6002=$2; + var $6003=(($6002+64)|0); + var $6004=HEAP32[(($6003)>>2)]; + var $6005=(($6004+4)|0); + var $6006=$6005; + var $6007=$6006; + var $6008=(($6007)|0); + HEAP32[(($6008)>>2)]=$6001; + var $6009=$2; + var $6010=(($6009+64)|0); + var $6011=HEAP32[(($6010)>>2)]; + var $6012=$st; + var $6013=(($6012+2)|0); + var $6014=$6013; + var $6015=HEAP16[(($6014)>>1)]; + var $6016=(($6015)&65535); + var $6017=(($6011+($6016<<2))|0); + var $6018=$6017; + var $6019=$6018; + var $6020=(($6019+4)|0); + var $6021=HEAP32[(($6020)>>2)]; + var $6022=$2; + var $6023=(($6022+64)|0); + var $6024=HEAP32[(($6023)>>2)]; + var $6025=(($6024+4)|0); + var $6026=$6025; + var $6027=$6026; + var $6028=(($6027+4)|0); + HEAP32[(($6028)>>2)]=$6021; + var $6029=$2; + var $6030=(($6029+64)|0); + var $6031=HEAP32[(($6030)>>2)]; + var $6032=$st; + var $6033=(($6032+2)|0); + var $6034=$6033; + var $6035=HEAP16[(($6034)>>1)]; + var $6036=(($6035)&65535); + var $6037=(($6031+($6036<<2))|0); + var $6038=$6037; + var $6039=$6038; + var $6040=(($6039+8)|0); + var $6041=HEAP32[(($6040)>>2)]; + var $6042=$2; + var $6043=(($6042+64)|0); + var $6044=HEAP32[(($6043)>>2)]; + var $6045=(($6044+4)|0); + var $6046=$6045; + var $6047=$6046; + var $6048=(($6047+8)|0); + HEAP32[(($6048)>>2)]=$6041; + var $6049=$2; + var $6050=(($6049+4)|0); + var $6051=HEAP32[(($6050)>>2)]; + var $6052=$2; + var $6053=_prog_leavefunction($6052); + var $6054=(($6051+($6053<<3))|0); + $st=$6054; + var $6055=$2; + var $6056=(($6055+168)|0); + var $6057=HEAP32[(($6056)>>2)]; + var $6058=(($6057)|0)!=0; + if ($6058) { __label__ = 251; break; } else { __label__ = 250; break; } + case 250: + __label__ = 488; break; + case 251: + __label__ = 366; break; + case 252: + var $6062=$2; + var $6063=(($6062+64)|0); + var $6064=HEAP32[(($6063)>>2)]; + var $6065=$st; + var $6066=(($6065+2)|0); + var $6067=$6066; + var $6068=HEAP16[(($6067)>>1)]; + var $6069=(($6068)&65535); + var $6070=(($6064+($6069<<2))|0); + var $6071=$6070; + var $6072=$6071; + var $6073=HEAPF32[(($6072)>>2)]; + var $6074=$2; + var $6075=(($6074+64)|0); + var $6076=HEAP32[(($6075)>>2)]; + var $6077=$st; + var $6078=(($6077+4)|0); + var $6079=$6078; + var $6080=HEAP16[(($6079)>>1)]; + var $6081=(($6080)&65535); + var $6082=(($6076+($6081<<2))|0); + var $6083=$6082; + var $6084=$6083; + var $6085=HEAPF32[(($6084)>>2)]; + var $6086=($6073)*($6085); + var $6087=$2; + var $6088=(($6087+64)|0); + var $6089=HEAP32[(($6088)>>2)]; + var $6090=$st; + var $6091=(($6090+6)|0); + var $6092=$6091; + var $6093=HEAP16[(($6092)>>1)]; + var $6094=(($6093)&65535); + var $6095=(($6089+($6094<<2))|0); + var $6096=$6095; + var $6097=$6096; + HEAPF32[(($6097)>>2)]=$6086; + __label__ = 366; break; + case 253: + var $6099=$2; + var $6100=(($6099+64)|0); + var $6101=HEAP32[(($6100)>>2)]; + var $6102=$st; + var $6103=(($6102+2)|0); + var $6104=$6103; + var $6105=HEAP16[(($6104)>>1)]; + var $6106=(($6105)&65535); + var $6107=(($6101+($6106<<2))|0); + var $6108=$6107; + var $6109=$6108; + var $6110=(($6109)|0); + var $6111=HEAPF32[(($6110)>>2)]; + var $6112=$2; + var $6113=(($6112+64)|0); + var $6114=HEAP32[(($6113)>>2)]; + var $6115=$st; + var $6116=(($6115+4)|0); + var $6117=$6116; + var $6118=HEAP16[(($6117)>>1)]; + var $6119=(($6118)&65535); + var $6120=(($6114+($6119<<2))|0); + var $6121=$6120; + var $6122=$6121; + var $6123=(($6122)|0); + var $6124=HEAPF32[(($6123)>>2)]; + var $6125=($6111)*($6124); + var $6126=$2; + var $6127=(($6126+64)|0); + var $6128=HEAP32[(($6127)>>2)]; + var $6129=$st; + var $6130=(($6129+2)|0); + var $6131=$6130; + var $6132=HEAP16[(($6131)>>1)]; + var $6133=(($6132)&65535); + var $6134=(($6128+($6133<<2))|0); + var $6135=$6134; + var $6136=$6135; + var $6137=(($6136+4)|0); + var $6138=HEAPF32[(($6137)>>2)]; + var $6139=$2; + var $6140=(($6139+64)|0); + var $6141=HEAP32[(($6140)>>2)]; + var $6142=$st; + var $6143=(($6142+4)|0); + var $6144=$6143; + var $6145=HEAP16[(($6144)>>1)]; + var $6146=(($6145)&65535); + var $6147=(($6141+($6146<<2))|0); + var $6148=$6147; + var $6149=$6148; + var $6150=(($6149+4)|0); + var $6151=HEAPF32[(($6150)>>2)]; + var $6152=($6138)*($6151); + var $6153=($6125)+($6152); + var $6154=$2; + var $6155=(($6154+64)|0); + var $6156=HEAP32[(($6155)>>2)]; + var $6157=$st; + var $6158=(($6157+2)|0); + var $6159=$6158; + var $6160=HEAP16[(($6159)>>1)]; + var $6161=(($6160)&65535); + var $6162=(($6156+($6161<<2))|0); + var $6163=$6162; + var $6164=$6163; + var $6165=(($6164+8)|0); + var $6166=HEAPF32[(($6165)>>2)]; + var $6167=$2; + var $6168=(($6167+64)|0); + var $6169=HEAP32[(($6168)>>2)]; + var $6170=$st; + var $6171=(($6170+4)|0); + var $6172=$6171; + var $6173=HEAP16[(($6172)>>1)]; + var $6174=(($6173)&65535); + var $6175=(($6169+($6174<<2))|0); + var $6176=$6175; + var $6177=$6176; + var $6178=(($6177+8)|0); + var $6179=HEAPF32[(($6178)>>2)]; + var $6180=($6166)*($6179); + var $6181=($6153)+($6180); + var $6182=$2; + var $6183=(($6182+64)|0); + var $6184=HEAP32[(($6183)>>2)]; + var $6185=$st; + var $6186=(($6185+6)|0); + var $6187=$6186; + var $6188=HEAP16[(($6187)>>1)]; + var $6189=(($6188)&65535); + var $6190=(($6184+($6189<<2))|0); + var $6191=$6190; + var $6192=$6191; + HEAPF32[(($6192)>>2)]=$6181; + __label__ = 366; break; + case 254: + var $6194=$2; + var $6195=(($6194+64)|0); + var $6196=HEAP32[(($6195)>>2)]; + var $6197=$st; + var $6198=(($6197+2)|0); + var $6199=$6198; + var $6200=HEAP16[(($6199)>>1)]; + var $6201=(($6200)&65535); + var $6202=(($6196+($6201<<2))|0); + var $6203=$6202; + var $6204=$6203; + var $6205=HEAPF32[(($6204)>>2)]; + var $6206=$2; + var $6207=(($6206+64)|0); + var $6208=HEAP32[(($6207)>>2)]; + var $6209=$st; + var $6210=(($6209+4)|0); + var $6211=$6210; + var $6212=HEAP16[(($6211)>>1)]; + var $6213=(($6212)&65535); + var $6214=(($6208+($6213<<2))|0); + var $6215=$6214; + var $6216=$6215; + var $6217=(($6216)|0); + var $6218=HEAPF32[(($6217)>>2)]; + var $6219=($6205)*($6218); + var $6220=$2; + var $6221=(($6220+64)|0); + var $6222=HEAP32[(($6221)>>2)]; + var $6223=$st; + var $6224=(($6223+6)|0); + var $6225=$6224; + var $6226=HEAP16[(($6225)>>1)]; + var $6227=(($6226)&65535); + var $6228=(($6222+($6227<<2))|0); + var $6229=$6228; + var $6230=$6229; + var $6231=(($6230)|0); + HEAPF32[(($6231)>>2)]=$6219; + var $6232=$2; + var $6233=(($6232+64)|0); + var $6234=HEAP32[(($6233)>>2)]; + var $6235=$st; + var $6236=(($6235+2)|0); + var $6237=$6236; + var $6238=HEAP16[(($6237)>>1)]; + var $6239=(($6238)&65535); + var $6240=(($6234+($6239<<2))|0); + var $6241=$6240; + var $6242=$6241; + var $6243=HEAPF32[(($6242)>>2)]; + var $6244=$2; + var $6245=(($6244+64)|0); + var $6246=HEAP32[(($6245)>>2)]; + var $6247=$st; + var $6248=(($6247+4)|0); + var $6249=$6248; + var $6250=HEAP16[(($6249)>>1)]; + var $6251=(($6250)&65535); + var $6252=(($6246+($6251<<2))|0); + var $6253=$6252; + var $6254=$6253; + var $6255=(($6254+4)|0); + var $6256=HEAPF32[(($6255)>>2)]; + var $6257=($6243)*($6256); + var $6258=$2; + var $6259=(($6258+64)|0); + var $6260=HEAP32[(($6259)>>2)]; + var $6261=$st; + var $6262=(($6261+6)|0); + var $6263=$6262; + var $6264=HEAP16[(($6263)>>1)]; + var $6265=(($6264)&65535); + var $6266=(($6260+($6265<<2))|0); + var $6267=$6266; + var $6268=$6267; + var $6269=(($6268+4)|0); + HEAPF32[(($6269)>>2)]=$6257; + var $6270=$2; + var $6271=(($6270+64)|0); + var $6272=HEAP32[(($6271)>>2)]; + var $6273=$st; + var $6274=(($6273+2)|0); + var $6275=$6274; + var $6276=HEAP16[(($6275)>>1)]; + var $6277=(($6276)&65535); + var $6278=(($6272+($6277<<2))|0); + var $6279=$6278; + var $6280=$6279; + var $6281=HEAPF32[(($6280)>>2)]; + var $6282=$2; + var $6283=(($6282+64)|0); + var $6284=HEAP32[(($6283)>>2)]; + var $6285=$st; + var $6286=(($6285+4)|0); + var $6287=$6286; + var $6288=HEAP16[(($6287)>>1)]; + var $6289=(($6288)&65535); + var $6290=(($6284+($6289<<2))|0); + var $6291=$6290; + var $6292=$6291; + var $6293=(($6292+8)|0); + var $6294=HEAPF32[(($6293)>>2)]; + var $6295=($6281)*($6294); + var $6296=$2; + var $6297=(($6296+64)|0); + var $6298=HEAP32[(($6297)>>2)]; + var $6299=$st; + var $6300=(($6299+6)|0); + var $6301=$6300; + var $6302=HEAP16[(($6301)>>1)]; + var $6303=(($6302)&65535); + var $6304=(($6298+($6303<<2))|0); + var $6305=$6304; + var $6306=$6305; + var $6307=(($6306+8)|0); + HEAPF32[(($6307)>>2)]=$6295; + __label__ = 366; break; + case 255: + var $6309=$2; + var $6310=(($6309+64)|0); + var $6311=HEAP32[(($6310)>>2)]; + var $6312=$st; + var $6313=(($6312+4)|0); + var $6314=$6313; + var $6315=HEAP16[(($6314)>>1)]; + var $6316=(($6315)&65535); + var $6317=(($6311+($6316<<2))|0); + var $6318=$6317; + var $6319=$6318; + var $6320=HEAPF32[(($6319)>>2)]; + var $6321=$2; + var $6322=(($6321+64)|0); + var $6323=HEAP32[(($6322)>>2)]; + var $6324=$st; + var $6325=(($6324+2)|0); + var $6326=$6325; + var $6327=HEAP16[(($6326)>>1)]; + var $6328=(($6327)&65535); + var $6329=(($6323+($6328<<2))|0); + var $6330=$6329; + var $6331=$6330; + var $6332=(($6331)|0); + var $6333=HEAPF32[(($6332)>>2)]; + var $6334=($6320)*($6333); + var $6335=$2; + var $6336=(($6335+64)|0); + var $6337=HEAP32[(($6336)>>2)]; + var $6338=$st; + var $6339=(($6338+6)|0); + var $6340=$6339; + var $6341=HEAP16[(($6340)>>1)]; + var $6342=(($6341)&65535); + var $6343=(($6337+($6342<<2))|0); + var $6344=$6343; + var $6345=$6344; + var $6346=(($6345)|0); + HEAPF32[(($6346)>>2)]=$6334; + var $6347=$2; + var $6348=(($6347+64)|0); + var $6349=HEAP32[(($6348)>>2)]; + var $6350=$st; + var $6351=(($6350+4)|0); + var $6352=$6351; + var $6353=HEAP16[(($6352)>>1)]; + var $6354=(($6353)&65535); + var $6355=(($6349+($6354<<2))|0); + var $6356=$6355; + var $6357=$6356; + var $6358=HEAPF32[(($6357)>>2)]; + var $6359=$2; + var $6360=(($6359+64)|0); + var $6361=HEAP32[(($6360)>>2)]; + var $6362=$st; + var $6363=(($6362+2)|0); + var $6364=$6363; + var $6365=HEAP16[(($6364)>>1)]; + var $6366=(($6365)&65535); + var $6367=(($6361+($6366<<2))|0); + var $6368=$6367; + var $6369=$6368; + var $6370=(($6369+4)|0); + var $6371=HEAPF32[(($6370)>>2)]; + var $6372=($6358)*($6371); + var $6373=$2; + var $6374=(($6373+64)|0); + var $6375=HEAP32[(($6374)>>2)]; + var $6376=$st; + var $6377=(($6376+6)|0); + var $6378=$6377; + var $6379=HEAP16[(($6378)>>1)]; + var $6380=(($6379)&65535); + var $6381=(($6375+($6380<<2))|0); + var $6382=$6381; + var $6383=$6382; + var $6384=(($6383+4)|0); + HEAPF32[(($6384)>>2)]=$6372; + var $6385=$2; + var $6386=(($6385+64)|0); + var $6387=HEAP32[(($6386)>>2)]; + var $6388=$st; + var $6389=(($6388+4)|0); + var $6390=$6389; + var $6391=HEAP16[(($6390)>>1)]; + var $6392=(($6391)&65535); + var $6393=(($6387+($6392<<2))|0); + var $6394=$6393; + var $6395=$6394; + var $6396=HEAPF32[(($6395)>>2)]; + var $6397=$2; + var $6398=(($6397+64)|0); + var $6399=HEAP32[(($6398)>>2)]; + var $6400=$st; + var $6401=(($6400+2)|0); + var $6402=$6401; + var $6403=HEAP16[(($6402)>>1)]; + var $6404=(($6403)&65535); + var $6405=(($6399+($6404<<2))|0); + var $6406=$6405; + var $6407=$6406; + var $6408=(($6407+8)|0); + var $6409=HEAPF32[(($6408)>>2)]; + var $6410=($6396)*($6409); + var $6411=$2; + var $6412=(($6411+64)|0); + var $6413=HEAP32[(($6412)>>2)]; + var $6414=$st; + var $6415=(($6414+6)|0); + var $6416=$6415; + var $6417=HEAP16[(($6416)>>1)]; + var $6418=(($6417)&65535); + var $6419=(($6413+($6418<<2))|0); + var $6420=$6419; + var $6421=$6420; + var $6422=(($6421+8)|0); + HEAPF32[(($6422)>>2)]=$6410; + __label__ = 366; break; + case 256: + var $6424=$2; + var $6425=(($6424+64)|0); + var $6426=HEAP32[(($6425)>>2)]; + var $6427=$st; + var $6428=(($6427+4)|0); + var $6429=$6428; + var $6430=HEAP16[(($6429)>>1)]; + var $6431=(($6430)&65535); + var $6432=(($6426+($6431<<2))|0); + var $6433=$6432; + var $6434=$6433; + var $6435=HEAPF32[(($6434)>>2)]; + var $6436=$6435 != 0; + if ($6436) { __label__ = 257; break; } else { __label__ = 258; break; } + case 257: + var $6438=$2; + var $6439=(($6438+64)|0); + var $6440=HEAP32[(($6439)>>2)]; + var $6441=$st; + var $6442=(($6441+2)|0); + var $6443=$6442; + var $6444=HEAP16[(($6443)>>1)]; + var $6445=(($6444)&65535); + var $6446=(($6440+($6445<<2))|0); + var $6447=$6446; + var $6448=$6447; + var $6449=HEAPF32[(($6448)>>2)]; + var $6450=$2; + var $6451=(($6450+64)|0); + var $6452=HEAP32[(($6451)>>2)]; + var $6453=$st; + var $6454=(($6453+4)|0); + var $6455=$6454; + var $6456=HEAP16[(($6455)>>1)]; + var $6457=(($6456)&65535); + var $6458=(($6452+($6457<<2))|0); + var $6459=$6458; + var $6460=$6459; + var $6461=HEAPF32[(($6460)>>2)]; + var $6462=($6449)/($6461); + var $6463=$2; + var $6464=(($6463+64)|0); + var $6465=HEAP32[(($6464)>>2)]; + var $6466=$st; + var $6467=(($6466+6)|0); + var $6468=$6467; + var $6469=HEAP16[(($6468)>>1)]; + var $6470=(($6469)&65535); + var $6471=(($6465+($6470<<2))|0); + var $6472=$6471; + var $6473=$6472; + HEAPF32[(($6473)>>2)]=$6462; + __label__ = 259; break; + case 258: + var $6475=$2; + var $6476=(($6475+64)|0); + var $6477=HEAP32[(($6476)>>2)]; + var $6478=$st; + var $6479=(($6478+6)|0); + var $6480=$6479; + var $6481=HEAP16[(($6480)>>1)]; + var $6482=(($6481)&65535); + var $6483=(($6477+($6482<<2))|0); + var $6484=$6483; + var $6485=$6484; + HEAPF32[(($6485)>>2)]=0; + __label__ = 259; break; + case 259: + __label__ = 366; break; + case 260: + var $6488=$2; + var $6489=(($6488+64)|0); + var $6490=HEAP32[(($6489)>>2)]; + var $6491=$st; + var $6492=(($6491+2)|0); + var $6493=$6492; + var $6494=HEAP16[(($6493)>>1)]; + var $6495=(($6494)&65535); + var $6496=(($6490+($6495<<2))|0); + var $6497=$6496; + var $6498=$6497; + var $6499=HEAPF32[(($6498)>>2)]; + var $6500=$2; + var $6501=(($6500+64)|0); + var $6502=HEAP32[(($6501)>>2)]; + var $6503=$st; + var $6504=(($6503+4)|0); + var $6505=$6504; + var $6506=HEAP16[(($6505)>>1)]; + var $6507=(($6506)&65535); + var $6508=(($6502+($6507<<2))|0); + var $6509=$6508; + var $6510=$6509; + var $6511=HEAPF32[(($6510)>>2)]; + var $6512=($6499)+($6511); + var $6513=$2; + var $6514=(($6513+64)|0); + var $6515=HEAP32[(($6514)>>2)]; + var $6516=$st; + var $6517=(($6516+6)|0); + var $6518=$6517; + var $6519=HEAP16[(($6518)>>1)]; + var $6520=(($6519)&65535); + var $6521=(($6515+($6520<<2))|0); + var $6522=$6521; + var $6523=$6522; + HEAPF32[(($6523)>>2)]=$6512; + __label__ = 366; break; + case 261: + var $6525=$2; + var $6526=(($6525+64)|0); + var $6527=HEAP32[(($6526)>>2)]; + var $6528=$st; + var $6529=(($6528+2)|0); + var $6530=$6529; + var $6531=HEAP16[(($6530)>>1)]; + var $6532=(($6531)&65535); + var $6533=(($6527+($6532<<2))|0); + var $6534=$6533; + var $6535=$6534; + var $6536=(($6535)|0); + var $6537=HEAPF32[(($6536)>>2)]; + var $6538=$2; + var $6539=(($6538+64)|0); + var $6540=HEAP32[(($6539)>>2)]; + var $6541=$st; + var $6542=(($6541+4)|0); + var $6543=$6542; + var $6544=HEAP16[(($6543)>>1)]; + var $6545=(($6544)&65535); + var $6546=(($6540+($6545<<2))|0); + var $6547=$6546; + var $6548=$6547; + var $6549=(($6548)|0); + var $6550=HEAPF32[(($6549)>>2)]; + var $6551=($6537)+($6550); + var $6552=$2; + var $6553=(($6552+64)|0); + var $6554=HEAP32[(($6553)>>2)]; + var $6555=$st; + var $6556=(($6555+6)|0); + var $6557=$6556; + var $6558=HEAP16[(($6557)>>1)]; + var $6559=(($6558)&65535); + var $6560=(($6554+($6559<<2))|0); + var $6561=$6560; + var $6562=$6561; + var $6563=(($6562)|0); + HEAPF32[(($6563)>>2)]=$6551; + var $6564=$2; + var $6565=(($6564+64)|0); + var $6566=HEAP32[(($6565)>>2)]; + var $6567=$st; + var $6568=(($6567+2)|0); + var $6569=$6568; + var $6570=HEAP16[(($6569)>>1)]; + var $6571=(($6570)&65535); + var $6572=(($6566+($6571<<2))|0); + var $6573=$6572; + var $6574=$6573; + var $6575=(($6574+4)|0); + var $6576=HEAPF32[(($6575)>>2)]; + var $6577=$2; + var $6578=(($6577+64)|0); + var $6579=HEAP32[(($6578)>>2)]; + var $6580=$st; + var $6581=(($6580+4)|0); + var $6582=$6581; + var $6583=HEAP16[(($6582)>>1)]; + var $6584=(($6583)&65535); + var $6585=(($6579+($6584<<2))|0); + var $6586=$6585; + var $6587=$6586; + var $6588=(($6587+4)|0); + var $6589=HEAPF32[(($6588)>>2)]; + var $6590=($6576)+($6589); + var $6591=$2; + var $6592=(($6591+64)|0); + var $6593=HEAP32[(($6592)>>2)]; + var $6594=$st; + var $6595=(($6594+6)|0); + var $6596=$6595; + var $6597=HEAP16[(($6596)>>1)]; + var $6598=(($6597)&65535); + var $6599=(($6593+($6598<<2))|0); + var $6600=$6599; + var $6601=$6600; + var $6602=(($6601+4)|0); + HEAPF32[(($6602)>>2)]=$6590; + var $6603=$2; + var $6604=(($6603+64)|0); + var $6605=HEAP32[(($6604)>>2)]; + var $6606=$st; + var $6607=(($6606+2)|0); + var $6608=$6607; + var $6609=HEAP16[(($6608)>>1)]; + var $6610=(($6609)&65535); + var $6611=(($6605+($6610<<2))|0); + var $6612=$6611; + var $6613=$6612; + var $6614=(($6613+8)|0); + var $6615=HEAPF32[(($6614)>>2)]; + var $6616=$2; + var $6617=(($6616+64)|0); + var $6618=HEAP32[(($6617)>>2)]; + var $6619=$st; + var $6620=(($6619+4)|0); + var $6621=$6620; + var $6622=HEAP16[(($6621)>>1)]; + var $6623=(($6622)&65535); + var $6624=(($6618+($6623<<2))|0); + var $6625=$6624; + var $6626=$6625; + var $6627=(($6626+8)|0); + var $6628=HEAPF32[(($6627)>>2)]; + var $6629=($6615)+($6628); + var $6630=$2; + var $6631=(($6630+64)|0); + var $6632=HEAP32[(($6631)>>2)]; + var $6633=$st; + var $6634=(($6633+6)|0); + var $6635=$6634; + var $6636=HEAP16[(($6635)>>1)]; + var $6637=(($6636)&65535); + var $6638=(($6632+($6637<<2))|0); + var $6639=$6638; + var $6640=$6639; + var $6641=(($6640+8)|0); + HEAPF32[(($6641)>>2)]=$6629; + __label__ = 366; break; + case 262: + var $6643=$2; + var $6644=(($6643+64)|0); + var $6645=HEAP32[(($6644)>>2)]; + var $6646=$st; + var $6647=(($6646+2)|0); + var $6648=$6647; + var $6649=HEAP16[(($6648)>>1)]; + var $6650=(($6649)&65535); + var $6651=(($6645+($6650<<2))|0); + var $6652=$6651; + var $6653=$6652; + var $6654=HEAPF32[(($6653)>>2)]; + var $6655=$2; + var $6656=(($6655+64)|0); + var $6657=HEAP32[(($6656)>>2)]; + var $6658=$st; + var $6659=(($6658+4)|0); + var $6660=$6659; + var $6661=HEAP16[(($6660)>>1)]; + var $6662=(($6661)&65535); + var $6663=(($6657+($6662<<2))|0); + var $6664=$6663; + var $6665=$6664; + var $6666=HEAPF32[(($6665)>>2)]; + var $6667=($6654)-($6666); + var $6668=$2; + var $6669=(($6668+64)|0); + var $6670=HEAP32[(($6669)>>2)]; + var $6671=$st; + var $6672=(($6671+6)|0); + var $6673=$6672; + var $6674=HEAP16[(($6673)>>1)]; + var $6675=(($6674)&65535); + var $6676=(($6670+($6675<<2))|0); + var $6677=$6676; + var $6678=$6677; + HEAPF32[(($6678)>>2)]=$6667; + __label__ = 366; break; + case 263: + var $6680=$2; + var $6681=(($6680+64)|0); + var $6682=HEAP32[(($6681)>>2)]; + var $6683=$st; + var $6684=(($6683+2)|0); + var $6685=$6684; + var $6686=HEAP16[(($6685)>>1)]; + var $6687=(($6686)&65535); + var $6688=(($6682+($6687<<2))|0); + var $6689=$6688; + var $6690=$6689; + var $6691=(($6690)|0); + var $6692=HEAPF32[(($6691)>>2)]; + var $6693=$2; + var $6694=(($6693+64)|0); + var $6695=HEAP32[(($6694)>>2)]; + var $6696=$st; + var $6697=(($6696+4)|0); + var $6698=$6697; + var $6699=HEAP16[(($6698)>>1)]; + var $6700=(($6699)&65535); + var $6701=(($6695+($6700<<2))|0); + var $6702=$6701; + var $6703=$6702; + var $6704=(($6703)|0); + var $6705=HEAPF32[(($6704)>>2)]; + var $6706=($6692)-($6705); + var $6707=$2; + var $6708=(($6707+64)|0); + var $6709=HEAP32[(($6708)>>2)]; + var $6710=$st; + var $6711=(($6710+6)|0); + var $6712=$6711; + var $6713=HEAP16[(($6712)>>1)]; + var $6714=(($6713)&65535); + var $6715=(($6709+($6714<<2))|0); + var $6716=$6715; + var $6717=$6716; + var $6718=(($6717)|0); + HEAPF32[(($6718)>>2)]=$6706; + var $6719=$2; + var $6720=(($6719+64)|0); + var $6721=HEAP32[(($6720)>>2)]; + var $6722=$st; + var $6723=(($6722+2)|0); + var $6724=$6723; + var $6725=HEAP16[(($6724)>>1)]; + var $6726=(($6725)&65535); + var $6727=(($6721+($6726<<2))|0); + var $6728=$6727; + var $6729=$6728; + var $6730=(($6729+4)|0); + var $6731=HEAPF32[(($6730)>>2)]; + var $6732=$2; + var $6733=(($6732+64)|0); + var $6734=HEAP32[(($6733)>>2)]; + var $6735=$st; + var $6736=(($6735+4)|0); + var $6737=$6736; + var $6738=HEAP16[(($6737)>>1)]; + var $6739=(($6738)&65535); + var $6740=(($6734+($6739<<2))|0); + var $6741=$6740; + var $6742=$6741; + var $6743=(($6742+4)|0); + var $6744=HEAPF32[(($6743)>>2)]; + var $6745=($6731)-($6744); + var $6746=$2; + var $6747=(($6746+64)|0); + var $6748=HEAP32[(($6747)>>2)]; + var $6749=$st; + var $6750=(($6749+6)|0); + var $6751=$6750; + var $6752=HEAP16[(($6751)>>1)]; + var $6753=(($6752)&65535); + var $6754=(($6748+($6753<<2))|0); + var $6755=$6754; + var $6756=$6755; + var $6757=(($6756+4)|0); + HEAPF32[(($6757)>>2)]=$6745; + var $6758=$2; + var $6759=(($6758+64)|0); + var $6760=HEAP32[(($6759)>>2)]; + var $6761=$st; + var $6762=(($6761+2)|0); + var $6763=$6762; + var $6764=HEAP16[(($6763)>>1)]; + var $6765=(($6764)&65535); + var $6766=(($6760+($6765<<2))|0); + var $6767=$6766; + var $6768=$6767; + var $6769=(($6768+8)|0); + var $6770=HEAPF32[(($6769)>>2)]; + var $6771=$2; + var $6772=(($6771+64)|0); + var $6773=HEAP32[(($6772)>>2)]; + var $6774=$st; + var $6775=(($6774+4)|0); + var $6776=$6775; + var $6777=HEAP16[(($6776)>>1)]; + var $6778=(($6777)&65535); + var $6779=(($6773+($6778<<2))|0); + var $6780=$6779; + var $6781=$6780; + var $6782=(($6781+8)|0); + var $6783=HEAPF32[(($6782)>>2)]; + var $6784=($6770)-($6783); + var $6785=$2; + var $6786=(($6785+64)|0); + var $6787=HEAP32[(($6786)>>2)]; + var $6788=$st; + var $6789=(($6788+6)|0); + var $6790=$6789; + var $6791=HEAP16[(($6790)>>1)]; + var $6792=(($6791)&65535); + var $6793=(($6787+($6792<<2))|0); + var $6794=$6793; + var $6795=$6794; + var $6796=(($6795+8)|0); + HEAPF32[(($6796)>>2)]=$6784; + __label__ = 366; break; + case 264: + var $6798=$2; + var $6799=(($6798+64)|0); + var $6800=HEAP32[(($6799)>>2)]; + var $6801=$st; + var $6802=(($6801+2)|0); + var $6803=$6802; + var $6804=HEAP16[(($6803)>>1)]; + var $6805=(($6804)&65535); + var $6806=(($6800+($6805<<2))|0); + var $6807=$6806; + var $6808=$6807; + var $6809=HEAPF32[(($6808)>>2)]; + var $6810=$2; + var $6811=(($6810+64)|0); + var $6812=HEAP32[(($6811)>>2)]; + var $6813=$st; + var $6814=(($6813+4)|0); + var $6815=$6814; + var $6816=HEAP16[(($6815)>>1)]; + var $6817=(($6816)&65535); + var $6818=(($6812+($6817<<2))|0); + var $6819=$6818; + var $6820=$6819; + var $6821=HEAPF32[(($6820)>>2)]; + var $6822=$6809 == $6821; + var $6823=(($6822)&1); + var $6824=(($6823)|0); + var $6825=$2; + var $6826=(($6825+64)|0); + var $6827=HEAP32[(($6826)>>2)]; + var $6828=$st; + var $6829=(($6828+6)|0); + var $6830=$6829; + var $6831=HEAP16[(($6830)>>1)]; + var $6832=(($6831)&65535); + var $6833=(($6827+($6832<<2))|0); + var $6834=$6833; + var $6835=$6834; + HEAPF32[(($6835)>>2)]=$6824; + __label__ = 366; break; + case 265: + var $6837=$2; + var $6838=(($6837+64)|0); + var $6839=HEAP32[(($6838)>>2)]; + var $6840=$st; + var $6841=(($6840+2)|0); + var $6842=$6841; + var $6843=HEAP16[(($6842)>>1)]; + var $6844=(($6843)&65535); + var $6845=(($6839+($6844<<2))|0); + var $6846=$6845; + var $6847=$6846; + var $6848=(($6847)|0); + var $6849=HEAPF32[(($6848)>>2)]; + var $6850=$2; + var $6851=(($6850+64)|0); + var $6852=HEAP32[(($6851)>>2)]; + var $6853=$st; + var $6854=(($6853+4)|0); + var $6855=$6854; + var $6856=HEAP16[(($6855)>>1)]; + var $6857=(($6856)&65535); + var $6858=(($6852+($6857<<2))|0); + var $6859=$6858; + var $6860=$6859; + var $6861=(($6860)|0); + var $6862=HEAPF32[(($6861)>>2)]; + var $6863=$6849 == $6862; + if ($6863) { __label__ = 266; break; } else { var $6921 = 0;__label__ = 268; break; } + case 266: + var $6865=$2; + var $6866=(($6865+64)|0); + var $6867=HEAP32[(($6866)>>2)]; + var $6868=$st; + var $6869=(($6868+2)|0); + var $6870=$6869; + var $6871=HEAP16[(($6870)>>1)]; + var $6872=(($6871)&65535); + var $6873=(($6867+($6872<<2))|0); + var $6874=$6873; + var $6875=$6874; + var $6876=(($6875+4)|0); + var $6877=HEAPF32[(($6876)>>2)]; + var $6878=$2; + var $6879=(($6878+64)|0); + var $6880=HEAP32[(($6879)>>2)]; + var $6881=$st; + var $6882=(($6881+4)|0); + var $6883=$6882; + var $6884=HEAP16[(($6883)>>1)]; + var $6885=(($6884)&65535); + var $6886=(($6880+($6885<<2))|0); + var $6887=$6886; + var $6888=$6887; + var $6889=(($6888+4)|0); + var $6890=HEAPF32[(($6889)>>2)]; + var $6891=$6877 == $6890; + if ($6891) { __label__ = 267; break; } else { var $6921 = 0;__label__ = 268; break; } + case 267: + var $6893=$2; + var $6894=(($6893+64)|0); + var $6895=HEAP32[(($6894)>>2)]; + var $6896=$st; + var $6897=(($6896+2)|0); + var $6898=$6897; + var $6899=HEAP16[(($6898)>>1)]; + var $6900=(($6899)&65535); + var $6901=(($6895+($6900<<2))|0); + var $6902=$6901; + var $6903=$6902; + var $6904=(($6903+8)|0); + var $6905=HEAPF32[(($6904)>>2)]; + var $6906=$2; + var $6907=(($6906+64)|0); + var $6908=HEAP32[(($6907)>>2)]; + var $6909=$st; + var $6910=(($6909+4)|0); + var $6911=$6910; + var $6912=HEAP16[(($6911)>>1)]; + var $6913=(($6912)&65535); + var $6914=(($6908+($6913<<2))|0); + var $6915=$6914; + var $6916=$6915; + var $6917=(($6916+8)|0); + var $6918=HEAPF32[(($6917)>>2)]; + var $6919=$6905 == $6918; + var $6921 = $6919;__label__ = 268; break; + case 268: + var $6921; + var $6922=(($6921)&1); + var $6923=(($6922)|0); + var $6924=$2; + var $6925=(($6924+64)|0); + var $6926=HEAP32[(($6925)>>2)]; + var $6927=$st; + var $6928=(($6927+6)|0); + var $6929=$6928; + var $6930=HEAP16[(($6929)>>1)]; + var $6931=(($6930)&65535); + var $6932=(($6926+($6931<<2))|0); + var $6933=$6932; + var $6934=$6933; + HEAPF32[(($6934)>>2)]=$6923; + __label__ = 366; break; + case 269: + var $6936=$2; + var $6937=$2; + var $6938=(($6937+64)|0); + var $6939=HEAP32[(($6938)>>2)]; + var $6940=$st; + var $6941=(($6940+2)|0); + var $6942=$6941; + var $6943=HEAP16[(($6942)>>1)]; + var $6944=(($6943)&65535); + var $6945=(($6939+($6944<<2))|0); + var $6946=$6945; + var $6947=$6946; + var $6948=HEAP32[(($6947)>>2)]; + var $6949=_prog_getstring($6936, $6948); + var $6950=$2; + var $6951=$2; + var $6952=(($6951+64)|0); + var $6953=HEAP32[(($6952)>>2)]; + var $6954=$st; + var $6955=(($6954+4)|0); + var $6956=$6955; + var $6957=HEAP16[(($6956)>>1)]; + var $6958=(($6957)&65535); + var $6959=(($6953+($6958<<2))|0); + var $6960=$6959; + var $6961=$6960; + var $6962=HEAP32[(($6961)>>2)]; + var $6963=_prog_getstring($6950, $6962); + var $6964=_strcmp($6949, $6963); + var $6965=(($6964)|0)!=0; + var $6966=$6965 ^ 1; + var $6967=(($6966)&1); + var $6968=(($6967)|0); + var $6969=$2; + var $6970=(($6969+64)|0); + var $6971=HEAP32[(($6970)>>2)]; + var $6972=$st; + var $6973=(($6972+6)|0); + var $6974=$6973; + var $6975=HEAP16[(($6974)>>1)]; + var $6976=(($6975)&65535); + var $6977=(($6971+($6976<<2))|0); + var $6978=$6977; + var $6979=$6978; + HEAPF32[(($6979)>>2)]=$6968; + __label__ = 366; break; + case 270: + var $6981=$2; + var $6982=(($6981+64)|0); + var $6983=HEAP32[(($6982)>>2)]; + var $6984=$st; + var $6985=(($6984+2)|0); + var $6986=$6985; + var $6987=HEAP16[(($6986)>>1)]; + var $6988=(($6987)&65535); + var $6989=(($6983+($6988<<2))|0); + var $6990=$6989; + var $6991=$6990; + var $6992=HEAP32[(($6991)>>2)]; + var $6993=$2; + var $6994=(($6993+64)|0); + var $6995=HEAP32[(($6994)>>2)]; + var $6996=$st; + var $6997=(($6996+4)|0); + var $6998=$6997; + var $6999=HEAP16[(($6998)>>1)]; + var $7000=(($6999)&65535); + var $7001=(($6995+($7000<<2))|0); + var $7002=$7001; + var $7003=$7002; + var $7004=HEAP32[(($7003)>>2)]; + var $7005=(($6992)|0)==(($7004)|0); + var $7006=(($7005)&1); + var $7007=(($7006)|0); + var $7008=$2; + var $7009=(($7008+64)|0); + var $7010=HEAP32[(($7009)>>2)]; + var $7011=$st; + var $7012=(($7011+6)|0); + var $7013=$7012; + var $7014=HEAP16[(($7013)>>1)]; + var $7015=(($7014)&65535); + var $7016=(($7010+($7015<<2))|0); + var $7017=$7016; + var $7018=$7017; + HEAPF32[(($7018)>>2)]=$7007; + __label__ = 366; break; + case 271: + var $7020=$2; + var $7021=(($7020+64)|0); + var $7022=HEAP32[(($7021)>>2)]; + var $7023=$st; + var $7024=(($7023+2)|0); + var $7025=$7024; + var $7026=HEAP16[(($7025)>>1)]; + var $7027=(($7026)&65535); + var $7028=(($7022+($7027<<2))|0); + var $7029=$7028; + var $7030=$7029; + var $7031=HEAP32[(($7030)>>2)]; + var $7032=$2; + var $7033=(($7032+64)|0); + var $7034=HEAP32[(($7033)>>2)]; + var $7035=$st; + var $7036=(($7035+4)|0); + var $7037=$7036; + var $7038=HEAP16[(($7037)>>1)]; + var $7039=(($7038)&65535); + var $7040=(($7034+($7039<<2))|0); + var $7041=$7040; + var $7042=$7041; + var $7043=HEAP32[(($7042)>>2)]; + var $7044=(($7031)|0)==(($7043)|0); + var $7045=(($7044)&1); + var $7046=(($7045)|0); + var $7047=$2; + var $7048=(($7047+64)|0); + var $7049=HEAP32[(($7048)>>2)]; + var $7050=$st; + var $7051=(($7050+6)|0); + var $7052=$7051; + var $7053=HEAP16[(($7052)>>1)]; + var $7054=(($7053)&65535); + var $7055=(($7049+($7054<<2))|0); + var $7056=$7055; + var $7057=$7056; + HEAPF32[(($7057)>>2)]=$7046; + __label__ = 366; break; + case 272: + var $7059=$2; + var $7060=(($7059+64)|0); + var $7061=HEAP32[(($7060)>>2)]; + var $7062=$st; + var $7063=(($7062+2)|0); + var $7064=$7063; + var $7065=HEAP16[(($7064)>>1)]; + var $7066=(($7065)&65535); + var $7067=(($7061+($7066<<2))|0); + var $7068=$7067; + var $7069=$7068; + var $7070=HEAPF32[(($7069)>>2)]; + var $7071=$2; + var $7072=(($7071+64)|0); + var $7073=HEAP32[(($7072)>>2)]; + var $7074=$st; + var $7075=(($7074+4)|0); + var $7076=$7075; + var $7077=HEAP16[(($7076)>>1)]; + var $7078=(($7077)&65535); + var $7079=(($7073+($7078<<2))|0); + var $7080=$7079; + var $7081=$7080; + var $7082=HEAPF32[(($7081)>>2)]; + var $7083=$7070 != $7082; + var $7084=(($7083)&1); + var $7085=(($7084)|0); + var $7086=$2; + var $7087=(($7086+64)|0); + var $7088=HEAP32[(($7087)>>2)]; + var $7089=$st; + var $7090=(($7089+6)|0); + var $7091=$7090; + var $7092=HEAP16[(($7091)>>1)]; + var $7093=(($7092)&65535); + var $7094=(($7088+($7093<<2))|0); + var $7095=$7094; + var $7096=$7095; + HEAPF32[(($7096)>>2)]=$7085; + __label__ = 366; break; + case 273: + var $7098=$2; + var $7099=(($7098+64)|0); + var $7100=HEAP32[(($7099)>>2)]; + var $7101=$st; + var $7102=(($7101+2)|0); + var $7103=$7102; + var $7104=HEAP16[(($7103)>>1)]; + var $7105=(($7104)&65535); + var $7106=(($7100+($7105<<2))|0); + var $7107=$7106; + var $7108=$7107; + var $7109=(($7108)|0); + var $7110=HEAPF32[(($7109)>>2)]; + var $7111=$2; + var $7112=(($7111+64)|0); + var $7113=HEAP32[(($7112)>>2)]; + var $7114=$st; + var $7115=(($7114+4)|0); + var $7116=$7115; + var $7117=HEAP16[(($7116)>>1)]; + var $7118=(($7117)&65535); + var $7119=(($7113+($7118<<2))|0); + var $7120=$7119; + var $7121=$7120; + var $7122=(($7121)|0); + var $7123=HEAPF32[(($7122)>>2)]; + var $7124=$7110 != $7123; + if ($7124) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 274; break; } + case 274: + var $7126=$2; + var $7127=(($7126+64)|0); + var $7128=HEAP32[(($7127)>>2)]; + var $7129=$st; + var $7130=(($7129+2)|0); + var $7131=$7130; + var $7132=HEAP16[(($7131)>>1)]; + var $7133=(($7132)&65535); + var $7134=(($7128+($7133<<2))|0); + var $7135=$7134; + var $7136=$7135; + var $7137=(($7136+4)|0); + var $7138=HEAPF32[(($7137)>>2)]; + var $7139=$2; + var $7140=(($7139+64)|0); + var $7141=HEAP32[(($7140)>>2)]; + var $7142=$st; + var $7143=(($7142+4)|0); + var $7144=$7143; + var $7145=HEAP16[(($7144)>>1)]; + var $7146=(($7145)&65535); + var $7147=(($7141+($7146<<2))|0); + var $7148=$7147; + var $7149=$7148; + var $7150=(($7149+4)|0); + var $7151=HEAPF32[(($7150)>>2)]; + var $7152=$7138 != $7151; + if ($7152) { var $7182 = 1;__label__ = 276; break; } else { __label__ = 275; break; } + case 275: + var $7154=$2; + var $7155=(($7154+64)|0); + var $7156=HEAP32[(($7155)>>2)]; + var $7157=$st; + var $7158=(($7157+2)|0); + var $7159=$7158; + var $7160=HEAP16[(($7159)>>1)]; + var $7161=(($7160)&65535); + var $7162=(($7156+($7161<<2))|0); + var $7163=$7162; + var $7164=$7163; + var $7165=(($7164+8)|0); + var $7166=HEAPF32[(($7165)>>2)]; + var $7167=$2; + var $7168=(($7167+64)|0); + var $7169=HEAP32[(($7168)>>2)]; + var $7170=$st; + var $7171=(($7170+4)|0); + var $7172=$7171; + var $7173=HEAP16[(($7172)>>1)]; + var $7174=(($7173)&65535); + var $7175=(($7169+($7174<<2))|0); + var $7176=$7175; + var $7177=$7176; + var $7178=(($7177+8)|0); + var $7179=HEAPF32[(($7178)>>2)]; + var $7180=$7166 != $7179; + var $7182 = $7180;__label__ = 276; break; + case 276: + var $7182; + var $7183=(($7182)&1); + var $7184=(($7183)|0); + var $7185=$2; + var $7186=(($7185+64)|0); + var $7187=HEAP32[(($7186)>>2)]; + var $7188=$st; + var $7189=(($7188+6)|0); + var $7190=$7189; + var $7191=HEAP16[(($7190)>>1)]; + var $7192=(($7191)&65535); + var $7193=(($7187+($7192<<2))|0); + var $7194=$7193; + var $7195=$7194; + HEAPF32[(($7195)>>2)]=$7184; + __label__ = 366; break; + case 277: + var $7197=$2; + var $7198=$2; + var $7199=(($7198+64)|0); + var $7200=HEAP32[(($7199)>>2)]; + var $7201=$st; + var $7202=(($7201+2)|0); + var $7203=$7202; + var $7204=HEAP16[(($7203)>>1)]; + var $7205=(($7204)&65535); + var $7206=(($7200+($7205<<2))|0); + var $7207=$7206; + var $7208=$7207; + var $7209=HEAP32[(($7208)>>2)]; + var $7210=_prog_getstring($7197, $7209); + var $7211=$2; + var $7212=$2; + var $7213=(($7212+64)|0); + var $7214=HEAP32[(($7213)>>2)]; + var $7215=$st; + var $7216=(($7215+4)|0); + var $7217=$7216; + var $7218=HEAP16[(($7217)>>1)]; + var $7219=(($7218)&65535); + var $7220=(($7214+($7219<<2))|0); + var $7221=$7220; + var $7222=$7221; + var $7223=HEAP32[(($7222)>>2)]; + var $7224=_prog_getstring($7211, $7223); + var $7225=_strcmp($7210, $7224); + var $7226=(($7225)|0)!=0; + var $7227=$7226 ^ 1; + var $7228=$7227 ^ 1; + var $7229=(($7228)&1); + var $7230=(($7229)|0); + var $7231=$2; + var $7232=(($7231+64)|0); + var $7233=HEAP32[(($7232)>>2)]; + var $7234=$st; + var $7235=(($7234+6)|0); + var $7236=$7235; + var $7237=HEAP16[(($7236)>>1)]; + var $7238=(($7237)&65535); + var $7239=(($7233+($7238<<2))|0); + var $7240=$7239; + var $7241=$7240; + HEAPF32[(($7241)>>2)]=$7230; + __label__ = 366; break; + case 278: + var $7243=$2; + var $7244=(($7243+64)|0); + var $7245=HEAP32[(($7244)>>2)]; + var $7246=$st; + var $7247=(($7246+2)|0); + var $7248=$7247; + var $7249=HEAP16[(($7248)>>1)]; + var $7250=(($7249)&65535); + var $7251=(($7245+($7250<<2))|0); + var $7252=$7251; + var $7253=$7252; + var $7254=HEAP32[(($7253)>>2)]; + var $7255=$2; + var $7256=(($7255+64)|0); + var $7257=HEAP32[(($7256)>>2)]; + var $7258=$st; + var $7259=(($7258+4)|0); + var $7260=$7259; + var $7261=HEAP16[(($7260)>>1)]; + var $7262=(($7261)&65535); + var $7263=(($7257+($7262<<2))|0); + var $7264=$7263; + var $7265=$7264; + var $7266=HEAP32[(($7265)>>2)]; + var $7267=(($7254)|0)!=(($7266)|0); + var $7268=(($7267)&1); + var $7269=(($7268)|0); + var $7270=$2; + var $7271=(($7270+64)|0); + var $7272=HEAP32[(($7271)>>2)]; + var $7273=$st; + var $7274=(($7273+6)|0); + var $7275=$7274; + var $7276=HEAP16[(($7275)>>1)]; + var $7277=(($7276)&65535); + var $7278=(($7272+($7277<<2))|0); + var $7279=$7278; + var $7280=$7279; + HEAPF32[(($7280)>>2)]=$7269; + __label__ = 366; break; + case 279: + var $7282=$2; + var $7283=(($7282+64)|0); + var $7284=HEAP32[(($7283)>>2)]; + var $7285=$st; + var $7286=(($7285+2)|0); + var $7287=$7286; + var $7288=HEAP16[(($7287)>>1)]; + var $7289=(($7288)&65535); + var $7290=(($7284+($7289<<2))|0); + var $7291=$7290; + var $7292=$7291; + var $7293=HEAP32[(($7292)>>2)]; + var $7294=$2; + var $7295=(($7294+64)|0); + var $7296=HEAP32[(($7295)>>2)]; + var $7297=$st; + var $7298=(($7297+4)|0); + var $7299=$7298; + var $7300=HEAP16[(($7299)>>1)]; + var $7301=(($7300)&65535); + var $7302=(($7296+($7301<<2))|0); + var $7303=$7302; + var $7304=$7303; + var $7305=HEAP32[(($7304)>>2)]; + var $7306=(($7293)|0)!=(($7305)|0); + var $7307=(($7306)&1); + var $7308=(($7307)|0); + var $7309=$2; + var $7310=(($7309+64)|0); + var $7311=HEAP32[(($7310)>>2)]; + var $7312=$st; + var $7313=(($7312+6)|0); + var $7314=$7313; + var $7315=HEAP16[(($7314)>>1)]; + var $7316=(($7315)&65535); + var $7317=(($7311+($7316<<2))|0); + var $7318=$7317; + var $7319=$7318; + HEAPF32[(($7319)>>2)]=$7308; + __label__ = 366; break; + case 280: + var $7321=$2; + var $7322=(($7321+64)|0); + var $7323=HEAP32[(($7322)>>2)]; + var $7324=$st; + var $7325=(($7324+2)|0); + var $7326=$7325; + var $7327=HEAP16[(($7326)>>1)]; + var $7328=(($7327)&65535); + var $7329=(($7323+($7328<<2))|0); + var $7330=$7329; + var $7331=$7330; + var $7332=HEAPF32[(($7331)>>2)]; + var $7333=$2; + var $7334=(($7333+64)|0); + var $7335=HEAP32[(($7334)>>2)]; + var $7336=$st; + var $7337=(($7336+4)|0); + var $7338=$7337; + var $7339=HEAP16[(($7338)>>1)]; + var $7340=(($7339)&65535); + var $7341=(($7335+($7340<<2))|0); + var $7342=$7341; + var $7343=$7342; + var $7344=HEAPF32[(($7343)>>2)]; + var $7345=$7332 <= $7344; + var $7346=(($7345)&1); + var $7347=(($7346)|0); + var $7348=$2; + var $7349=(($7348+64)|0); + var $7350=HEAP32[(($7349)>>2)]; + var $7351=$st; + var $7352=(($7351+6)|0); + var $7353=$7352; + var $7354=HEAP16[(($7353)>>1)]; + var $7355=(($7354)&65535); + var $7356=(($7350+($7355<<2))|0); + var $7357=$7356; + var $7358=$7357; + HEAPF32[(($7358)>>2)]=$7347; + __label__ = 366; break; + case 281: + var $7360=$2; + var $7361=(($7360+64)|0); + var $7362=HEAP32[(($7361)>>2)]; + var $7363=$st; + var $7364=(($7363+2)|0); + var $7365=$7364; + var $7366=HEAP16[(($7365)>>1)]; + var $7367=(($7366)&65535); + var $7368=(($7362+($7367<<2))|0); + var $7369=$7368; + var $7370=$7369; + var $7371=HEAPF32[(($7370)>>2)]; + var $7372=$2; + var $7373=(($7372+64)|0); + var $7374=HEAP32[(($7373)>>2)]; + var $7375=$st; + var $7376=(($7375+4)|0); + var $7377=$7376; + var $7378=HEAP16[(($7377)>>1)]; + var $7379=(($7378)&65535); + var $7380=(($7374+($7379<<2))|0); + var $7381=$7380; + var $7382=$7381; + var $7383=HEAPF32[(($7382)>>2)]; + var $7384=$7371 >= $7383; + var $7385=(($7384)&1); + var $7386=(($7385)|0); + var $7387=$2; + var $7388=(($7387+64)|0); + var $7389=HEAP32[(($7388)>>2)]; + var $7390=$st; + var $7391=(($7390+6)|0); + var $7392=$7391; + var $7393=HEAP16[(($7392)>>1)]; + var $7394=(($7393)&65535); + var $7395=(($7389+($7394<<2))|0); + var $7396=$7395; + var $7397=$7396; + HEAPF32[(($7397)>>2)]=$7386; + __label__ = 366; break; + case 282: + var $7399=$2; + var $7400=(($7399+64)|0); + var $7401=HEAP32[(($7400)>>2)]; + var $7402=$st; + var $7403=(($7402+2)|0); + var $7404=$7403; + var $7405=HEAP16[(($7404)>>1)]; + var $7406=(($7405)&65535); + var $7407=(($7401+($7406<<2))|0); + var $7408=$7407; + var $7409=$7408; + var $7410=HEAPF32[(($7409)>>2)]; + var $7411=$2; + var $7412=(($7411+64)|0); + var $7413=HEAP32[(($7412)>>2)]; + var $7414=$st; + var $7415=(($7414+4)|0); + var $7416=$7415; + var $7417=HEAP16[(($7416)>>1)]; + var $7418=(($7417)&65535); + var $7419=(($7413+($7418<<2))|0); + var $7420=$7419; + var $7421=$7420; + var $7422=HEAPF32[(($7421)>>2)]; + var $7423=$7410 < $7422; + var $7424=(($7423)&1); + var $7425=(($7424)|0); + var $7426=$2; + var $7427=(($7426+64)|0); + var $7428=HEAP32[(($7427)>>2)]; + var $7429=$st; + var $7430=(($7429+6)|0); + var $7431=$7430; + var $7432=HEAP16[(($7431)>>1)]; + var $7433=(($7432)&65535); + var $7434=(($7428+($7433<<2))|0); + var $7435=$7434; + var $7436=$7435; + HEAPF32[(($7436)>>2)]=$7425; + __label__ = 366; break; + case 283: + var $7438=$2; + var $7439=(($7438+64)|0); + var $7440=HEAP32[(($7439)>>2)]; + var $7441=$st; + var $7442=(($7441+2)|0); + var $7443=$7442; + var $7444=HEAP16[(($7443)>>1)]; + var $7445=(($7444)&65535); + var $7446=(($7440+($7445<<2))|0); + var $7447=$7446; + var $7448=$7447; + var $7449=HEAPF32[(($7448)>>2)]; + var $7450=$2; + var $7451=(($7450+64)|0); + var $7452=HEAP32[(($7451)>>2)]; + var $7453=$st; + var $7454=(($7453+4)|0); + var $7455=$7454; + var $7456=HEAP16[(($7455)>>1)]; + var $7457=(($7456)&65535); + var $7458=(($7452+($7457<<2))|0); + var $7459=$7458; + var $7460=$7459; + var $7461=HEAPF32[(($7460)>>2)]; + var $7462=$7449 > $7461; + var $7463=(($7462)&1); + var $7464=(($7463)|0); + var $7465=$2; + var $7466=(($7465+64)|0); + var $7467=HEAP32[(($7466)>>2)]; + var $7468=$st; + var $7469=(($7468+6)|0); + var $7470=$7469; + var $7471=HEAP16[(($7470)>>1)]; + var $7472=(($7471)&65535); + var $7473=(($7467+($7472<<2))|0); + var $7474=$7473; + var $7475=$7474; + HEAPF32[(($7475)>>2)]=$7464; + __label__ = 366; break; + case 284: + var $7477=$2; + var $7478=(($7477+64)|0); + var $7479=HEAP32[(($7478)>>2)]; + var $7480=$st; + var $7481=(($7480+2)|0); + var $7482=$7481; + var $7483=HEAP16[(($7482)>>1)]; + var $7484=(($7483)&65535); + var $7485=(($7479+($7484<<2))|0); + var $7486=$7485; + var $7487=$7486; + var $7488=HEAP32[(($7487)>>2)]; + var $7489=(($7488)|0) < 0; + if ($7489) { __label__ = 286; break; } else { __label__ = 285; break; } + case 285: + var $7491=$2; + var $7492=(($7491+64)|0); + var $7493=HEAP32[(($7492)>>2)]; + var $7494=$st; + var $7495=(($7494+2)|0); + var $7496=$7495; + var $7497=HEAP16[(($7496)>>1)]; + var $7498=(($7497)&65535); + var $7499=(($7493+($7498<<2))|0); + var $7500=$7499; + var $7501=$7500; + var $7502=HEAP32[(($7501)>>2)]; + var $7503=$2; + var $7504=(($7503+140)|0); + var $7505=HEAP32[(($7504)>>2)]; + var $7506=(($7502)|0) >= (($7505)|0); + if ($7506) { __label__ = 286; break; } else { __label__ = 287; break; } + case 286: + var $7508=$2; + var $7509=$2; + var $7510=(($7509)|0); + var $7511=HEAP32[(($7510)>>2)]; + _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)); + __label__ = 488; break; + case 287: + var $7513=$2; + var $7514=(($7513+64)|0); + var $7515=HEAP32[(($7514)>>2)]; + var $7516=$st; + var $7517=(($7516+4)|0); + var $7518=$7517; + var $7519=HEAP16[(($7518)>>1)]; + var $7520=(($7519)&65535); + var $7521=(($7515+($7520<<2))|0); + var $7522=$7521; + var $7523=$7522; + var $7524=HEAP32[(($7523)>>2)]; + var $7525=$2; + var $7526=(($7525+144)|0); + var $7527=HEAP32[(($7526)>>2)]; + var $7528=(($7524)>>>0) >= (($7527)>>>0); + if ($7528) { __label__ = 288; break; } else { __label__ = 289; break; } + case 288: + var $7530=$2; + var $7531=$2; + var $7532=(($7531)|0); + var $7533=HEAP32[(($7532)>>2)]; + var $7534=$2; + var $7535=(($7534+64)|0); + var $7536=HEAP32[(($7535)>>2)]; + var $7537=$st; + var $7538=(($7537+4)|0); + var $7539=$7538; + var $7540=HEAP16[(($7539)>>1)]; + var $7541=(($7540)&65535); + var $7542=(($7536+($7541<<2))|0); + var $7543=$7542; + var $7544=$7543; + var $7545=HEAP32[(($7544)>>2)]; + _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)); + __label__ = 488; break; + case 289: + var $7547=$2; + var $7548=$2; + var $7549=(($7548+64)|0); + var $7550=HEAP32[(($7549)>>2)]; + var $7551=$st; + var $7552=(($7551+2)|0); + var $7553=$7552; + var $7554=HEAP16[(($7553)>>1)]; + var $7555=(($7554)&65535); + var $7556=(($7550+($7555<<2))|0); + var $7557=$7556; + var $7558=$7557; + var $7559=HEAP32[(($7558)>>2)]; + var $7560=_prog_getedict($7547, $7559); + $ed6=$7560; + var $7561=$ed6; + var $7562=$7561; + var $7563=$2; + var $7564=(($7563+64)|0); + var $7565=HEAP32[(($7564)>>2)]; + var $7566=$st; + var $7567=(($7566+4)|0); + var $7568=$7567; + var $7569=HEAP16[(($7568)>>1)]; + var $7570=(($7569)&65535); + var $7571=(($7565+($7570<<2))|0); + var $7572=$7571; + var $7573=$7572; + var $7574=HEAP32[(($7573)>>2)]; + var $7575=(($7562+($7574<<2))|0); + var $7576=$7575; + var $7577=$7576; + var $7578=HEAP32[(($7577)>>2)]; + var $7579=$2; + var $7580=(($7579+64)|0); + var $7581=HEAP32[(($7580)>>2)]; + var $7582=$st; + var $7583=(($7582+6)|0); + var $7584=$7583; + var $7585=HEAP16[(($7584)>>1)]; + var $7586=(($7585)&65535); + var $7587=(($7581+($7586<<2))|0); + var $7588=$7587; + var $7589=$7588; + HEAP32[(($7589)>>2)]=$7578; + __label__ = 366; break; + case 290: + var $7591=$2; + var $7592=(($7591+64)|0); + var $7593=HEAP32[(($7592)>>2)]; + var $7594=$st; + var $7595=(($7594+2)|0); + var $7596=$7595; + var $7597=HEAP16[(($7596)>>1)]; + var $7598=(($7597)&65535); + var $7599=(($7593+($7598<<2))|0); + var $7600=$7599; + var $7601=$7600; + var $7602=HEAP32[(($7601)>>2)]; + var $7603=(($7602)|0) < 0; + if ($7603) { __label__ = 292; break; } else { __label__ = 291; break; } + case 291: + var $7605=$2; + var $7606=(($7605+64)|0); + var $7607=HEAP32[(($7606)>>2)]; + var $7608=$st; + var $7609=(($7608+2)|0); + var $7610=$7609; + var $7611=HEAP16[(($7610)>>1)]; + var $7612=(($7611)&65535); + var $7613=(($7607+($7612<<2))|0); + var $7614=$7613; + var $7615=$7614; + var $7616=HEAP32[(($7615)>>2)]; + var $7617=$2; + var $7618=(($7617+140)|0); + var $7619=HEAP32[(($7618)>>2)]; + var $7620=(($7616)|0) >= (($7619)|0); + if ($7620) { __label__ = 292; break; } else { __label__ = 293; break; } + case 292: + var $7622=$2; + var $7623=$2; + var $7624=(($7623)|0); + var $7625=HEAP32[(($7624)>>2)]; + _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)); + __label__ = 488; break; + case 293: + var $7627=$2; + var $7628=(($7627+64)|0); + var $7629=HEAP32[(($7628)>>2)]; + var $7630=$st; + var $7631=(($7630+4)|0); + var $7632=$7631; + var $7633=HEAP16[(($7632)>>1)]; + var $7634=(($7633)&65535); + var $7635=(($7629+($7634<<2))|0); + var $7636=$7635; + var $7637=$7636; + var $7638=HEAP32[(($7637)>>2)]; + var $7639=(($7638)|0) < 0; + if ($7639) { __label__ = 295; break; } else { __label__ = 294; break; } + case 294: + var $7641=$2; + var $7642=(($7641+64)|0); + var $7643=HEAP32[(($7642)>>2)]; + var $7644=$st; + var $7645=(($7644+4)|0); + var $7646=$7645; + var $7647=HEAP16[(($7646)>>1)]; + var $7648=(($7647)&65535); + var $7649=(($7643+($7648<<2))|0); + var $7650=$7649; + var $7651=$7650; + var $7652=HEAP32[(($7651)>>2)]; + var $7653=((($7652)+(3))|0); + var $7654=$2; + var $7655=(($7654+144)|0); + var $7656=HEAP32[(($7655)>>2)]; + var $7657=(($7653)>>>0) > (($7656)>>>0); + if ($7657) { __label__ = 295; break; } else { __label__ = 296; break; } + case 295: + var $7659=$2; + var $7660=$2; + var $7661=(($7660)|0); + var $7662=HEAP32[(($7661)>>2)]; + var $7663=$2; + var $7664=(($7663+64)|0); + var $7665=HEAP32[(($7664)>>2)]; + var $7666=$st; + var $7667=(($7666+4)|0); + var $7668=$7667; + var $7669=HEAP16[(($7668)>>1)]; + var $7670=(($7669)&65535); + var $7671=(($7665+($7670<<2))|0); + var $7672=$7671; + var $7673=$7672; + var $7674=HEAP32[(($7673)>>2)]; + var $7675=((($7674)+(2))|0); + _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)); + __label__ = 488; break; + case 296: + var $7677=$2; + var $7678=$2; + var $7679=(($7678+64)|0); + var $7680=HEAP32[(($7679)>>2)]; + var $7681=$st; + var $7682=(($7681+2)|0); + var $7683=$7682; + var $7684=HEAP16[(($7683)>>1)]; + var $7685=(($7684)&65535); + var $7686=(($7680+($7685<<2))|0); + var $7687=$7686; + var $7688=$7687; + var $7689=HEAP32[(($7688)>>2)]; + var $7690=_prog_getedict($7677, $7689); + $ed6=$7690; + var $7691=$ed6; + var $7692=$7691; + var $7693=$2; + var $7694=(($7693+64)|0); + var $7695=HEAP32[(($7694)>>2)]; + var $7696=$st; + var $7697=(($7696+4)|0); + var $7698=$7697; + var $7699=HEAP16[(($7698)>>1)]; + var $7700=(($7699)&65535); + var $7701=(($7695+($7700<<2))|0); + var $7702=$7701; + var $7703=$7702; + var $7704=HEAP32[(($7703)>>2)]; + var $7705=(($7692+($7704<<2))|0); + var $7706=$7705; + var $7707=$7706; + var $7708=(($7707)|0); + var $7709=HEAP32[(($7708)>>2)]; + var $7710=$2; + var $7711=(($7710+64)|0); + var $7712=HEAP32[(($7711)>>2)]; + var $7713=$st; + var $7714=(($7713+6)|0); + var $7715=$7714; + var $7716=HEAP16[(($7715)>>1)]; + var $7717=(($7716)&65535); + var $7718=(($7712+($7717<<2))|0); + var $7719=$7718; + var $7720=$7719; + var $7721=(($7720)|0); + HEAP32[(($7721)>>2)]=$7709; + var $7722=$ed6; + var $7723=$7722; + var $7724=$2; + var $7725=(($7724+64)|0); + var $7726=HEAP32[(($7725)>>2)]; + var $7727=$st; + var $7728=(($7727+4)|0); + var $7729=$7728; + var $7730=HEAP16[(($7729)>>1)]; + var $7731=(($7730)&65535); + var $7732=(($7726+($7731<<2))|0); + var $7733=$7732; + var $7734=$7733; + var $7735=HEAP32[(($7734)>>2)]; + var $7736=(($7723+($7735<<2))|0); + var $7737=$7736; + var $7738=$7737; + var $7739=(($7738+4)|0); + var $7740=HEAP32[(($7739)>>2)]; + var $7741=$2; + var $7742=(($7741+64)|0); + var $7743=HEAP32[(($7742)>>2)]; + var $7744=$st; + var $7745=(($7744+6)|0); + var $7746=$7745; + var $7747=HEAP16[(($7746)>>1)]; + var $7748=(($7747)&65535); + var $7749=(($7743+($7748<<2))|0); + var $7750=$7749; + var $7751=$7750; + var $7752=(($7751+4)|0); + HEAP32[(($7752)>>2)]=$7740; + var $7753=$ed6; + var $7754=$7753; + var $7755=$2; + var $7756=(($7755+64)|0); + var $7757=HEAP32[(($7756)>>2)]; + var $7758=$st; + var $7759=(($7758+4)|0); + var $7760=$7759; + var $7761=HEAP16[(($7760)>>1)]; + var $7762=(($7761)&65535); + var $7763=(($7757+($7762<<2))|0); + var $7764=$7763; + var $7765=$7764; + var $7766=HEAP32[(($7765)>>2)]; + var $7767=(($7754+($7766<<2))|0); + var $7768=$7767; + var $7769=$7768; + var $7770=(($7769+8)|0); + var $7771=HEAP32[(($7770)>>2)]; + var $7772=$2; + var $7773=(($7772+64)|0); + var $7774=HEAP32[(($7773)>>2)]; + var $7775=$st; + var $7776=(($7775+6)|0); + var $7777=$7776; + var $7778=HEAP16[(($7777)>>1)]; + var $7779=(($7778)&65535); + var $7780=(($7774+($7779<<2))|0); + var $7781=$7780; + var $7782=$7781; + var $7783=(($7782+8)|0); + HEAP32[(($7783)>>2)]=$7771; + __label__ = 366; break; + case 297: + var $7785=$2; + var $7786=(($7785+64)|0); + var $7787=HEAP32[(($7786)>>2)]; + var $7788=$st; + var $7789=(($7788+2)|0); + var $7790=$7789; + var $7791=HEAP16[(($7790)>>1)]; + var $7792=(($7791)&65535); + var $7793=(($7787+($7792<<2))|0); + var $7794=$7793; + var $7795=$7794; + var $7796=HEAP32[(($7795)>>2)]; + var $7797=(($7796)|0) < 0; + if ($7797) { __label__ = 299; break; } else { __label__ = 298; break; } + case 298: + var $7799=$2; + var $7800=(($7799+64)|0); + var $7801=HEAP32[(($7800)>>2)]; + var $7802=$st; + var $7803=(($7802+2)|0); + var $7804=$7803; + var $7805=HEAP16[(($7804)>>1)]; + var $7806=(($7805)&65535); + var $7807=(($7801+($7806<<2))|0); + var $7808=$7807; + var $7809=$7808; + var $7810=HEAP32[(($7809)>>2)]; + var $7811=$2; + var $7812=(($7811+140)|0); + var $7813=HEAP32[(($7812)>>2)]; + var $7814=(($7810)|0) >= (($7813)|0); + if ($7814) { __label__ = 299; break; } else { __label__ = 300; break; } + case 299: + var $7816=$2; + var $7817=$2; + var $7818=(($7817)|0); + var $7819=HEAP32[(($7818)>>2)]; + var $7820=$2; + var $7821=(($7820+64)|0); + var $7822=HEAP32[(($7821)>>2)]; + var $7823=$st; + var $7824=(($7823+2)|0); + var $7825=$7824; + var $7826=HEAP16[(($7825)>>1)]; + var $7827=(($7826)&65535); + var $7828=(($7822+($7827<<2))|0); + var $7829=$7828; + var $7830=$7829; + var $7831=HEAP32[(($7830)>>2)]; + _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)); + __label__ = 488; break; + case 300: + var $7833=$2; + var $7834=(($7833+64)|0); + var $7835=HEAP32[(($7834)>>2)]; + var $7836=$st; + var $7837=(($7836+4)|0); + var $7838=$7837; + var $7839=HEAP16[(($7838)>>1)]; + var $7840=(($7839)&65535); + var $7841=(($7835+($7840<<2))|0); + var $7842=$7841; + var $7843=$7842; + var $7844=HEAP32[(($7843)>>2)]; + var $7845=$2; + var $7846=(($7845+144)|0); + var $7847=HEAP32[(($7846)>>2)]; + var $7848=(($7844)>>>0) >= (($7847)>>>0); + if ($7848) { __label__ = 301; break; } else { __label__ = 302; break; } + case 301: + var $7850=$2; + var $7851=$2; + var $7852=(($7851)|0); + var $7853=HEAP32[(($7852)>>2)]; + var $7854=$2; + var $7855=(($7854+64)|0); + var $7856=HEAP32[(($7855)>>2)]; + var $7857=$st; + var $7858=(($7857+4)|0); + var $7859=$7858; + var $7860=HEAP16[(($7859)>>1)]; + var $7861=(($7860)&65535); + var $7862=(($7856+($7861<<2))|0); + var $7863=$7862; + var $7864=$7863; + var $7865=HEAP32[(($7864)>>2)]; + _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)); + __label__ = 488; break; + case 302: + var $7867=$2; + var $7868=$2; + var $7869=(($7868+64)|0); + var $7870=HEAP32[(($7869)>>2)]; + var $7871=$st; + var $7872=(($7871+2)|0); + var $7873=$7872; + var $7874=HEAP16[(($7873)>>1)]; + var $7875=(($7874)&65535); + var $7876=(($7870+($7875<<2))|0); + var $7877=$7876; + var $7878=$7877; + var $7879=HEAP32[(($7878)>>2)]; + var $7880=_prog_getedict($7867, $7879); + $ed6=$7880; + var $7881=$ed6; + var $7882=$7881; + var $7883=$2; + var $7884=(($7883+76)|0); + var $7885=HEAP32[(($7884)>>2)]; + var $7886=$7882; + var $7887=$7885; + var $7888=((($7886)-($7887))|0); + var $7889=((((($7888)|0))/(4))&-1); + var $7890=$2; + var $7891=(($7890+64)|0); + var $7892=HEAP32[(($7891)>>2)]; + var $7893=$st; + var $7894=(($7893+6)|0); + var $7895=$7894; + var $7896=HEAP16[(($7895)>>1)]; + var $7897=(($7896)&65535); + var $7898=(($7892+($7897<<2))|0); + var $7899=$7898; + var $7900=$7899; + HEAP32[(($7900)>>2)]=$7889; + var $7901=$2; + var $7902=(($7901+64)|0); + var $7903=HEAP32[(($7902)>>2)]; + var $7904=$st; + var $7905=(($7904+4)|0); + var $7906=$7905; + var $7907=HEAP16[(($7906)>>1)]; + var $7908=(($7907)&65535); + var $7909=(($7903+($7908<<2))|0); + var $7910=$7909; + var $7911=$7910; + var $7912=HEAP32[(($7911)>>2)]; + var $7913=$2; + var $7914=(($7913+64)|0); + var $7915=HEAP32[(($7914)>>2)]; + var $7916=$st; + var $7917=(($7916+6)|0); + var $7918=$7917; + var $7919=HEAP16[(($7918)>>1)]; + var $7920=(($7919)&65535); + var $7921=(($7915+($7920<<2))|0); + var $7922=$7921; + var $7923=$7922; + var $7924=HEAP32[(($7923)>>2)]; + var $7925=((($7924)+($7912))|0); + HEAP32[(($7923)>>2)]=$7925; + __label__ = 366; break; + case 303: + var $7927=$2; + var $7928=(($7927+64)|0); + var $7929=HEAP32[(($7928)>>2)]; + var $7930=$st; + var $7931=(($7930+2)|0); + var $7932=$7931; + var $7933=HEAP16[(($7932)>>1)]; + var $7934=(($7933)&65535); + var $7935=(($7929+($7934<<2))|0); + var $7936=$7935; + var $7937=$7936; + var $7938=HEAP32[(($7937)>>2)]; + var $7939=$2; + var $7940=(($7939+64)|0); + var $7941=HEAP32[(($7940)>>2)]; + var $7942=$st; + var $7943=(($7942+4)|0); + var $7944=$7943; + var $7945=HEAP16[(($7944)>>1)]; + var $7946=(($7945)&65535); + var $7947=(($7941+($7946<<2))|0); + var $7948=$7947; + var $7949=$7948; + HEAP32[(($7949)>>2)]=$7938; + __label__ = 366; break; + case 304: + var $7951=$2; + var $7952=(($7951+64)|0); + var $7953=HEAP32[(($7952)>>2)]; + var $7954=$st; + var $7955=(($7954+2)|0); + var $7956=$7955; + var $7957=HEAP16[(($7956)>>1)]; + var $7958=(($7957)&65535); + var $7959=(($7953+($7958<<2))|0); + var $7960=$7959; + var $7961=$7960; + var $7962=(($7961)|0); + var $7963=HEAP32[(($7962)>>2)]; + var $7964=$2; + var $7965=(($7964+64)|0); + var $7966=HEAP32[(($7965)>>2)]; + var $7967=$st; + var $7968=(($7967+4)|0); + var $7969=$7968; + var $7970=HEAP16[(($7969)>>1)]; + var $7971=(($7970)&65535); + var $7972=(($7966+($7971<<2))|0); + var $7973=$7972; + var $7974=$7973; + var $7975=(($7974)|0); + HEAP32[(($7975)>>2)]=$7963; + var $7976=$2; + var $7977=(($7976+64)|0); + var $7978=HEAP32[(($7977)>>2)]; + var $7979=$st; + var $7980=(($7979+2)|0); + var $7981=$7980; + var $7982=HEAP16[(($7981)>>1)]; + var $7983=(($7982)&65535); + var $7984=(($7978+($7983<<2))|0); + var $7985=$7984; + var $7986=$7985; + var $7987=(($7986+4)|0); + var $7988=HEAP32[(($7987)>>2)]; + var $7989=$2; + var $7990=(($7989+64)|0); + var $7991=HEAP32[(($7990)>>2)]; + var $7992=$st; + var $7993=(($7992+4)|0); + var $7994=$7993; + var $7995=HEAP16[(($7994)>>1)]; + var $7996=(($7995)&65535); + var $7997=(($7991+($7996<<2))|0); + var $7998=$7997; + var $7999=$7998; + var $8000=(($7999+4)|0); + HEAP32[(($8000)>>2)]=$7988; + var $8001=$2; + var $8002=(($8001+64)|0); + var $8003=HEAP32[(($8002)>>2)]; + var $8004=$st; + var $8005=(($8004+2)|0); + var $8006=$8005; + var $8007=HEAP16[(($8006)>>1)]; + var $8008=(($8007)&65535); + var $8009=(($8003+($8008<<2))|0); + var $8010=$8009; + var $8011=$8010; + var $8012=(($8011+8)|0); + var $8013=HEAP32[(($8012)>>2)]; + var $8014=$2; + var $8015=(($8014+64)|0); + var $8016=HEAP32[(($8015)>>2)]; + var $8017=$st; + var $8018=(($8017+4)|0); + var $8019=$8018; + var $8020=HEAP16[(($8019)>>1)]; + var $8021=(($8020)&65535); + var $8022=(($8016+($8021<<2))|0); + var $8023=$8022; + var $8024=$8023; + var $8025=(($8024+8)|0); + HEAP32[(($8025)>>2)]=$8013; + __label__ = 366; break; + case 305: + var $8027=$2; + var $8028=(($8027+64)|0); + var $8029=HEAP32[(($8028)>>2)]; + var $8030=$st; + var $8031=(($8030+4)|0); + var $8032=$8031; + var $8033=HEAP16[(($8032)>>1)]; + var $8034=(($8033)&65535); + var $8035=(($8029+($8034<<2))|0); + var $8036=$8035; + var $8037=$8036; + var $8038=HEAP32[(($8037)>>2)]; + var $8039=(($8038)|0) < 0; + if ($8039) { __label__ = 307; break; } else { __label__ = 306; break; } + case 306: + var $8041=$2; + var $8042=(($8041+64)|0); + var $8043=HEAP32[(($8042)>>2)]; + var $8044=$st; + var $8045=(($8044+4)|0); + var $8046=$8045; + var $8047=HEAP16[(($8046)>>1)]; + var $8048=(($8047)&65535); + var $8049=(($8043+($8048<<2))|0); + var $8050=$8049; + var $8051=$8050; + var $8052=HEAP32[(($8051)>>2)]; + var $8053=$2; + var $8054=(($8053+80)|0); + var $8055=HEAP32[(($8054)>>2)]; + var $8056=(($8052)>>>0) >= (($8055)>>>0); + if ($8056) { __label__ = 307; break; } else { __label__ = 308; break; } + case 307: + var $8058=$2; + var $8059=$2; + var $8060=(($8059)|0); + var $8061=HEAP32[(($8060)>>2)]; + var $8062=$2; + var $8063=(($8062+64)|0); + var $8064=HEAP32[(($8063)>>2)]; + var $8065=$st; + var $8066=(($8065+4)|0); + var $8067=$8066; + var $8068=HEAP16[(($8067)>>1)]; + var $8069=(($8068)&65535); + var $8070=(($8064+($8069<<2))|0); + var $8071=$8070; + var $8072=$8071; + var $8073=HEAP32[(($8072)>>2)]; + _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)); + __label__ = 488; break; + case 308: + var $8075=$2; + var $8076=(($8075+64)|0); + var $8077=HEAP32[(($8076)>>2)]; + var $8078=$st; + var $8079=(($8078+4)|0); + var $8080=$8079; + var $8081=HEAP16[(($8080)>>1)]; + var $8082=(($8081)&65535); + var $8083=(($8077+($8082<<2))|0); + var $8084=$8083; + var $8085=$8084; + var $8086=HEAP32[(($8085)>>2)]; + var $8087=$2; + var $8088=(($8087+144)|0); + var $8089=HEAP32[(($8088)>>2)]; + var $8090=(($8086)>>>0) < (($8089)>>>0); + if ($8090) { __label__ = 309; break; } else { __label__ = 311; break; } + case 309: + var $8092=$2; + var $8093=(($8092+148)|0); + var $8094=HEAP8[($8093)]; + var $8095=(($8094) & 1); + if ($8095) { __label__ = 311; break; } else { __label__ = 310; break; } + case 310: + var $8097=$2; + var $8098=$2; + var $8099=(($8098)|0); + var $8100=HEAP32[(($8099)>>2)]; + var $8101=$2; + var $8102=$2; + var $8103=$2; + var $8104=(($8103+64)|0); + var $8105=HEAP32[(($8104)>>2)]; + var $8106=$st; + var $8107=(($8106+4)|0); + var $8108=$8107; + var $8109=HEAP16[(($8108)>>1)]; + var $8110=(($8109)&65535); + var $8111=(($8105+($8110<<2))|0); + var $8112=$8111; + var $8113=$8112; + var $8114=HEAP32[(($8113)>>2)]; + var $8115=_prog_entfield($8102, $8114); + var $8116=(($8115+4)|0); + var $8117=HEAP32[(($8116)>>2)]; + var $8118=_prog_getstring($8101, $8117); + var $8119=$2; + var $8120=(($8119+64)|0); + var $8121=HEAP32[(($8120)>>2)]; + var $8122=$st; + var $8123=(($8122+4)|0); + var $8124=$8123; + var $8125=HEAP16[(($8124)>>1)]; + var $8126=(($8125)&65535); + var $8127=(($8121+($8126<<2))|0); + var $8128=$8127; + var $8129=$8128; + var $8130=HEAP32[(($8129)>>2)]; + _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)); + __label__ = 311; break; + case 311: + var $8132=$2; + var $8133=(($8132+76)|0); + var $8134=HEAP32[(($8133)>>2)]; + var $8135=$2; + var $8136=(($8135+64)|0); + var $8137=HEAP32[(($8136)>>2)]; + var $8138=$st; + var $8139=(($8138+4)|0); + var $8140=$8139; + var $8141=HEAP16[(($8140)>>1)]; + var $8142=(($8141)&65535); + var $8143=(($8137+($8142<<2))|0); + var $8144=$8143; + var $8145=$8144; + var $8146=HEAP32[(($8145)>>2)]; + var $8147=(($8134+($8146<<2))|0); + var $8148=$8147; + $ptr7=$8148; + var $8149=$2; + var $8150=(($8149+64)|0); + var $8151=HEAP32[(($8150)>>2)]; + var $8152=$st; + var $8153=(($8152+2)|0); + var $8154=$8153; + var $8155=HEAP16[(($8154)>>1)]; + var $8156=(($8155)&65535); + var $8157=(($8151+($8156<<2))|0); + var $8158=$8157; + var $8159=$8158; + var $8160=HEAP32[(($8159)>>2)]; + var $8161=$ptr7; + var $8162=$8161; + HEAP32[(($8162)>>2)]=$8160; + __label__ = 366; break; + case 312: + var $8164=$2; + var $8165=(($8164+64)|0); + var $8166=HEAP32[(($8165)>>2)]; + var $8167=$st; + var $8168=(($8167+4)|0); + var $8169=$8168; + var $8170=HEAP16[(($8169)>>1)]; + var $8171=(($8170)&65535); + var $8172=(($8166+($8171<<2))|0); + var $8173=$8172; + var $8174=$8173; + var $8175=HEAP32[(($8174)>>2)]; + var $8176=(($8175)|0) < 0; + if ($8176) { __label__ = 314; break; } else { __label__ = 313; break; } + case 313: + var $8178=$2; + var $8179=(($8178+64)|0); + var $8180=HEAP32[(($8179)>>2)]; + var $8181=$st; + var $8182=(($8181+4)|0); + var $8183=$8182; + var $8184=HEAP16[(($8183)>>1)]; + var $8185=(($8184)&65535); + var $8186=(($8180+($8185<<2))|0); + var $8187=$8186; + var $8188=$8187; + var $8189=HEAP32[(($8188)>>2)]; + var $8190=((($8189)+(2))|0); + var $8191=$2; + var $8192=(($8191+80)|0); + var $8193=HEAP32[(($8192)>>2)]; + var $8194=(($8190)>>>0) >= (($8193)>>>0); + if ($8194) { __label__ = 314; break; } else { __label__ = 315; break; } + case 314: + var $8196=$2; + var $8197=$2; + var $8198=(($8197)|0); + var $8199=HEAP32[(($8198)>>2)]; + var $8200=$2; + var $8201=(($8200+64)|0); + var $8202=HEAP32[(($8201)>>2)]; + var $8203=$st; + var $8204=(($8203+4)|0); + var $8205=$8204; + var $8206=HEAP16[(($8205)>>1)]; + var $8207=(($8206)&65535); + var $8208=(($8202+($8207<<2))|0); + var $8209=$8208; + var $8210=$8209; + var $8211=HEAP32[(($8210)>>2)]; + _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)); + __label__ = 488; break; + case 315: + var $8213=$2; + var $8214=(($8213+64)|0); + var $8215=HEAP32[(($8214)>>2)]; + var $8216=$st; + var $8217=(($8216+4)|0); + var $8218=$8217; + var $8219=HEAP16[(($8218)>>1)]; + var $8220=(($8219)&65535); + var $8221=(($8215+($8220<<2))|0); + var $8222=$8221; + var $8223=$8222; + var $8224=HEAP32[(($8223)>>2)]; + var $8225=$2; + var $8226=(($8225+144)|0); + var $8227=HEAP32[(($8226)>>2)]; + var $8228=(($8224)>>>0) < (($8227)>>>0); + if ($8228) { __label__ = 316; break; } else { __label__ = 318; break; } + case 316: + var $8230=$2; + var $8231=(($8230+148)|0); + var $8232=HEAP8[($8231)]; + var $8233=(($8232) & 1); + if ($8233) { __label__ = 318; break; } else { __label__ = 317; break; } + case 317: + var $8235=$2; + var $8236=$2; + var $8237=(($8236)|0); + var $8238=HEAP32[(($8237)>>2)]; + var $8239=$2; + var $8240=$2; + var $8241=$2; + var $8242=(($8241+64)|0); + var $8243=HEAP32[(($8242)>>2)]; + var $8244=$st; + var $8245=(($8244+4)|0); + var $8246=$8245; + var $8247=HEAP16[(($8246)>>1)]; + var $8248=(($8247)&65535); + var $8249=(($8243+($8248<<2))|0); + var $8250=$8249; + var $8251=$8250; + var $8252=HEAP32[(($8251)>>2)]; + var $8253=_prog_entfield($8240, $8252); + var $8254=(($8253+4)|0); + var $8255=HEAP32[(($8254)>>2)]; + var $8256=_prog_getstring($8239, $8255); + var $8257=$2; + var $8258=(($8257+64)|0); + var $8259=HEAP32[(($8258)>>2)]; + var $8260=$st; + var $8261=(($8260+4)|0); + var $8262=$8261; + var $8263=HEAP16[(($8262)>>1)]; + var $8264=(($8263)&65535); + var $8265=(($8259+($8264<<2))|0); + var $8266=$8265; + var $8267=$8266; + var $8268=HEAP32[(($8267)>>2)]; + _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)); + __label__ = 318; break; + case 318: + var $8270=$2; + var $8271=(($8270+76)|0); + var $8272=HEAP32[(($8271)>>2)]; + var $8273=$2; + var $8274=(($8273+64)|0); + var $8275=HEAP32[(($8274)>>2)]; + var $8276=$st; + var $8277=(($8276+4)|0); + var $8278=$8277; + var $8279=HEAP16[(($8278)>>1)]; + var $8280=(($8279)&65535); + var $8281=(($8275+($8280<<2))|0); + var $8282=$8281; + var $8283=$8282; + var $8284=HEAP32[(($8283)>>2)]; + var $8285=(($8272+($8284<<2))|0); + var $8286=$8285; + $ptr7=$8286; + var $8287=$2; + var $8288=(($8287+64)|0); + var $8289=HEAP32[(($8288)>>2)]; + var $8290=$st; + var $8291=(($8290+2)|0); + var $8292=$8291; + var $8293=HEAP16[(($8292)>>1)]; + var $8294=(($8293)&65535); + var $8295=(($8289+($8294<<2))|0); + var $8296=$8295; + var $8297=$8296; + var $8298=(($8297)|0); + var $8299=HEAP32[(($8298)>>2)]; + var $8300=$ptr7; + var $8301=$8300; + var $8302=(($8301)|0); + HEAP32[(($8302)>>2)]=$8299; + var $8303=$2; + var $8304=(($8303+64)|0); + var $8305=HEAP32[(($8304)>>2)]; + var $8306=$st; + var $8307=(($8306+2)|0); + var $8308=$8307; + var $8309=HEAP16[(($8308)>>1)]; + var $8310=(($8309)&65535); + var $8311=(($8305+($8310<<2))|0); + var $8312=$8311; + var $8313=$8312; + var $8314=(($8313+4)|0); + var $8315=HEAP32[(($8314)>>2)]; + var $8316=$ptr7; + var $8317=$8316; + var $8318=(($8317+4)|0); + HEAP32[(($8318)>>2)]=$8315; + var $8319=$2; + var $8320=(($8319+64)|0); + var $8321=HEAP32[(($8320)>>2)]; + var $8322=$st; + var $8323=(($8322+2)|0); + var $8324=$8323; + var $8325=HEAP16[(($8324)>>1)]; + var $8326=(($8325)&65535); + var $8327=(($8321+($8326<<2))|0); + var $8328=$8327; + var $8329=$8328; + var $8330=(($8329+8)|0); + var $8331=HEAP32[(($8330)>>2)]; + var $8332=$ptr7; + var $8333=$8332; + var $8334=(($8333+8)|0); + HEAP32[(($8334)>>2)]=$8331; + __label__ = 366; break; + case 319: + var $8336=$2; + var $8337=(($8336+64)|0); + var $8338=HEAP32[(($8337)>>2)]; + var $8339=$st; + var $8340=(($8339+2)|0); + var $8341=$8340; + var $8342=HEAP16[(($8341)>>1)]; + var $8343=(($8342)&65535); + var $8344=(($8338+($8343<<2))|0); + var $8345=$8344; + var $8346=$8345; + var $8347=HEAP32[(($8346)>>2)]; + var $8348=$8347 & 2147483647; + var $8349=(($8348)|0)!=0; + var $8350=$8349 ^ 1; + var $8351=(($8350)&1); + var $8352=(($8351)|0); + var $8353=$2; + var $8354=(($8353+64)|0); + var $8355=HEAP32[(($8354)>>2)]; + var $8356=$st; + var $8357=(($8356+6)|0); + var $8358=$8357; + var $8359=HEAP16[(($8358)>>1)]; + var $8360=(($8359)&65535); + var $8361=(($8355+($8360<<2))|0); + var $8362=$8361; + var $8363=$8362; + HEAPF32[(($8363)>>2)]=$8352; + __label__ = 366; break; + case 320: + var $8365=$2; + var $8366=(($8365+64)|0); + var $8367=HEAP32[(($8366)>>2)]; + var $8368=$st; + var $8369=(($8368+2)|0); + var $8370=$8369; + var $8371=HEAP16[(($8370)>>1)]; + var $8372=(($8371)&65535); + var $8373=(($8367+($8372<<2))|0); + var $8374=$8373; + var $8375=$8374; + var $8376=(($8375)|0); + var $8377=HEAPF32[(($8376)>>2)]; + var $8378=$8377 != 0; + if ($8378) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 321; break; } + case 321: + var $8380=$2; + var $8381=(($8380+64)|0); + var $8382=HEAP32[(($8381)>>2)]; + var $8383=$st; + var $8384=(($8383+2)|0); + var $8385=$8384; + var $8386=HEAP16[(($8385)>>1)]; + var $8387=(($8386)&65535); + var $8388=(($8382+($8387<<2))|0); + var $8389=$8388; + var $8390=$8389; + var $8391=(($8390+4)|0); + var $8392=HEAPF32[(($8391)>>2)]; + var $8393=$8392 != 0; + if ($8393) { var $8411 = 0;__label__ = 323; break; } else { __label__ = 322; break; } + case 322: + var $8395=$2; + var $8396=(($8395+64)|0); + var $8397=HEAP32[(($8396)>>2)]; + var $8398=$st; + var $8399=(($8398+2)|0); + var $8400=$8399; + var $8401=HEAP16[(($8400)>>1)]; + var $8402=(($8401)&65535); + var $8403=(($8397+($8402<<2))|0); + var $8404=$8403; + var $8405=$8404; + var $8406=(($8405+8)|0); + var $8407=HEAPF32[(($8406)>>2)]; + var $8408=$8407 != 0; + var $8409=$8408 ^ 1; + var $8411 = $8409;__label__ = 323; break; + case 323: + var $8411; + var $8412=(($8411)&1); + var $8413=(($8412)|0); + var $8414=$2; + var $8415=(($8414+64)|0); + var $8416=HEAP32[(($8415)>>2)]; + var $8417=$st; + var $8418=(($8417+6)|0); + var $8419=$8418; + var $8420=HEAP16[(($8419)>>1)]; + var $8421=(($8420)&65535); + var $8422=(($8416+($8421<<2))|0); + var $8423=$8422; + var $8424=$8423; + HEAPF32[(($8424)>>2)]=$8413; + __label__ = 366; break; + case 324: + var $8426=$2; + var $8427=(($8426+64)|0); + var $8428=HEAP32[(($8427)>>2)]; + var $8429=$st; + var $8430=(($8429+2)|0); + var $8431=$8430; + var $8432=HEAP16[(($8431)>>1)]; + var $8433=(($8432)&65535); + var $8434=(($8428+($8433<<2))|0); + var $8435=$8434; + var $8436=$8435; + var $8437=HEAP32[(($8436)>>2)]; + var $8438=(($8437)|0)!=0; + if ($8438) { __label__ = 325; break; } else { var $8458 = 1;__label__ = 326; break; } + case 325: + var $8440=$2; + var $8441=$2; + var $8442=(($8441+64)|0); + var $8443=HEAP32[(($8442)>>2)]; + var $8444=$st; + var $8445=(($8444+2)|0); + var $8446=$8445; + var $8447=HEAP16[(($8446)>>1)]; + var $8448=(($8447)&65535); + var $8449=(($8443+($8448<<2))|0); + var $8450=$8449; + var $8451=$8450; + var $8452=HEAP32[(($8451)>>2)]; + var $8453=_prog_getstring($8440, $8452); + var $8454=HEAP8[($8453)]; + var $8455=(($8454 << 24) >> 24)!=0; + var $8456=$8455 ^ 1; + var $8458 = $8456;__label__ = 326; break; + case 326: + var $8458; + var $8459=(($8458)&1); + var $8460=(($8459)|0); + var $8461=$2; + var $8462=(($8461+64)|0); + var $8463=HEAP32[(($8462)>>2)]; + var $8464=$st; + var $8465=(($8464+6)|0); + var $8466=$8465; + var $8467=HEAP16[(($8466)>>1)]; + var $8468=(($8467)&65535); + var $8469=(($8463+($8468<<2))|0); + var $8470=$8469; + var $8471=$8470; + HEAPF32[(($8471)>>2)]=$8460; + __label__ = 366; break; + case 327: + var $8473=$2; + var $8474=(($8473+64)|0); + var $8475=HEAP32[(($8474)>>2)]; + var $8476=$st; + var $8477=(($8476+2)|0); + var $8478=$8477; + var $8479=HEAP16[(($8478)>>1)]; + var $8480=(($8479)&65535); + var $8481=(($8475+($8480<<2))|0); + var $8482=$8481; + var $8483=$8482; + var $8484=HEAP32[(($8483)>>2)]; + var $8485=(($8484)|0)==0; + var $8486=(($8485)&1); + var $8487=(($8486)|0); + var $8488=$2; + var $8489=(($8488+64)|0); + var $8490=HEAP32[(($8489)>>2)]; + var $8491=$st; + var $8492=(($8491+6)|0); + var $8493=$8492; + var $8494=HEAP16[(($8493)>>1)]; + var $8495=(($8494)&65535); + var $8496=(($8490+($8495<<2))|0); + var $8497=$8496; + var $8498=$8497; + HEAPF32[(($8498)>>2)]=$8487; + __label__ = 366; break; + case 328: + var $8500=$2; + var $8501=(($8500+64)|0); + var $8502=HEAP32[(($8501)>>2)]; + var $8503=$st; + var $8504=(($8503+2)|0); + var $8505=$8504; + var $8506=HEAP16[(($8505)>>1)]; + var $8507=(($8506)&65535); + var $8508=(($8502+($8507<<2))|0); + var $8509=$8508; + var $8510=$8509; + var $8511=HEAP32[(($8510)>>2)]; + var $8512=(($8511)|0)!=0; + var $8513=$8512 ^ 1; + var $8514=(($8513)&1); + var $8515=(($8514)|0); + var $8516=$2; + var $8517=(($8516+64)|0); + var $8518=HEAP32[(($8517)>>2)]; + var $8519=$st; + var $8520=(($8519+6)|0); + var $8521=$8520; + var $8522=HEAP16[(($8521)>>1)]; + var $8523=(($8522)&65535); + var $8524=(($8518+($8523<<2))|0); + var $8525=$8524; + var $8526=$8525; + HEAPF32[(($8526)>>2)]=$8515; + __label__ = 366; break; + case 329: + var $8528=$2; + var $8529=(($8528+64)|0); + var $8530=HEAP32[(($8529)>>2)]; + var $8531=$st; + var $8532=(($8531+2)|0); + var $8533=$8532; + var $8534=HEAP16[(($8533)>>1)]; + var $8535=(($8534)&65535); + var $8536=(($8530+($8535<<2))|0); + var $8537=$8536; + var $8538=$8537; + var $8539=HEAP32[(($8538)>>2)]; + var $8540=$8539 & 2147483647; + var $8541=(($8540)|0)!=0; + if ($8541) { __label__ = 330; break; } else { __label__ = 333; break; } + case 330: + var $8543=$st; + var $8544=(($8543+4)|0); + var $8545=$8544; + var $8546=HEAP16[(($8545)>>1)]; + var $8547=(($8546 << 16) >> 16); + var $8548=((($8547)-(1))|0); + var $8549=$st; + var $8550=(($8549+($8548<<3))|0); + $st=$8550; + var $8551=$jumpcount; + var $8552=((($8551)+(1))|0); + $jumpcount=$8552; + var $8553=$5; + var $8554=(($8552)|0) >= (($8553)|0); + if ($8554) { __label__ = 331; break; } else { __label__ = 332; break; } + case 331: + var $8556=$2; + var $8557=$2; + var $8558=(($8557)|0); + var $8559=HEAP32[(($8558)>>2)]; + var $8560=$jumpcount; + _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)); + __label__ = 332; break; + case 332: + __label__ = 333; break; + case 333: + __label__ = 366; break; + case 334: + var $8564=$2; + var $8565=(($8564+64)|0); + var $8566=HEAP32[(($8565)>>2)]; + var $8567=$st; + var $8568=(($8567+2)|0); + var $8569=$8568; + var $8570=HEAP16[(($8569)>>1)]; + var $8571=(($8570)&65535); + var $8572=(($8566+($8571<<2))|0); + var $8573=$8572; + var $8574=$8573; + var $8575=HEAP32[(($8574)>>2)]; + var $8576=$8575 & 2147483647; + var $8577=(($8576)|0)!=0; + if ($8577) { __label__ = 338; break; } else { __label__ = 335; break; } + case 335: + var $8579=$st; + var $8580=(($8579+4)|0); + var $8581=$8580; + var $8582=HEAP16[(($8581)>>1)]; + var $8583=(($8582 << 16) >> 16); + var $8584=((($8583)-(1))|0); + var $8585=$st; + var $8586=(($8585+($8584<<3))|0); + $st=$8586; + var $8587=$jumpcount; + var $8588=((($8587)+(1))|0); + $jumpcount=$8588; + var $8589=$5; + var $8590=(($8588)|0) >= (($8589)|0); + if ($8590) { __label__ = 336; break; } else { __label__ = 337; break; } + case 336: + var $8592=$2; + var $8593=$2; + var $8594=(($8593)|0); + var $8595=HEAP32[(($8594)>>2)]; + var $8596=$jumpcount; + _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)); + __label__ = 337; break; + case 337: + __label__ = 338; break; + case 338: + __label__ = 366; break; + case 339: + var $8600=$st; + var $8601=(($8600)|0); + var $8602=HEAP16[(($8601)>>1)]; + var $8603=(($8602)&65535); + var $8604=((($8603)-(51))|0); + var $8605=$2; + var $8606=(($8605+184)|0); + HEAP32[(($8606)>>2)]=$8604; + var $8607=$2; + var $8608=(($8607+64)|0); + var $8609=HEAP32[(($8608)>>2)]; + var $8610=$st; + var $8611=(($8610+2)|0); + var $8612=$8611; + var $8613=HEAP16[(($8612)>>1)]; + var $8614=(($8613)&65535); + var $8615=(($8609+($8614<<2))|0); + var $8616=$8615; + var $8617=$8616; + var $8618=HEAP32[(($8617)>>2)]; + var $8619=(($8618)|0)!=0; + if ($8619) { __label__ = 341; break; } else { __label__ = 340; break; } + case 340: + var $8621=$2; + var $8622=$2; + var $8623=(($8622)|0); + var $8624=HEAP32[(($8623)>>2)]; + _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)); + __label__ = 341; break; + case 341: + var $8626=$2; + var $8627=(($8626+64)|0); + var $8628=HEAP32[(($8627)>>2)]; + var $8629=$st; + var $8630=(($8629+2)|0); + var $8631=$8630; + var $8632=HEAP16[(($8631)>>1)]; + var $8633=(($8632)&65535); + var $8634=(($8628+($8633<<2))|0); + var $8635=$8634; + var $8636=$8635; + var $8637=HEAP32[(($8636)>>2)]; + var $8638=(($8637)|0)!=0; + if ($8638) { __label__ = 342; break; } else { __label__ = 343; break; } + case 342: + var $8640=$2; + var $8641=(($8640+64)|0); + var $8642=HEAP32[(($8641)>>2)]; + var $8643=$st; + var $8644=(($8643+2)|0); + var $8645=$8644; + var $8646=HEAP16[(($8645)>>1)]; + var $8647=(($8646)&65535); + var $8648=(($8642+($8647<<2))|0); + var $8649=$8648; + var $8650=$8649; + var $8651=HEAP32[(($8650)>>2)]; + var $8652=$2; + var $8653=(($8652+44)|0); + var $8654=HEAP32[(($8653)>>2)]; + var $8655=(($8651)>>>0) >= (($8654)>>>0); + if ($8655) { __label__ = 343; break; } else { __label__ = 344; break; } + case 343: + var $8657=$2; + var $8658=$2; + var $8659=(($8658)|0); + var $8660=HEAP32[(($8659)>>2)]; + _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)); + __label__ = 488; break; + case 344: + var $8662=$2; + var $8663=(($8662+64)|0); + var $8664=HEAP32[(($8663)>>2)]; + var $8665=$st; + var $8666=(($8665+2)|0); + var $8667=$8666; + var $8668=HEAP16[(($8667)>>1)]; + var $8669=(($8668)&65535); + var $8670=(($8664+($8669<<2))|0); + var $8671=$8670; + var $8672=$8671; + var $8673=HEAP32[(($8672)>>2)]; + var $8674=$2; + var $8675=(($8674+40)|0); + var $8676=HEAP32[(($8675)>>2)]; + var $8677=(($8676+($8673)*(36))|0); + $newf5=$8677; + var $8678=$newf5; + var $8679=(($8678+12)|0); + var $8680=HEAP32[(($8679)>>2)]; + var $8681=((($8680)+(1))|0); + HEAP32[(($8679)>>2)]=$8681; + var $8682=$st; + var $8683=$2; + var $8684=(($8683+4)|0); + var $8685=HEAP32[(($8684)>>2)]; + var $8686=$8682; + var $8687=$8685; + var $8688=((($8686)-($8687))|0); + var $8689=((((($8688)|0))/(8))&-1); + var $8690=((($8689)+(1))|0); + var $8691=$2; + var $8692=(($8691+176)|0); + HEAP32[(($8692)>>2)]=$8690; + var $8693=$newf5; + var $8694=(($8693)|0); + var $8695=HEAP32[(($8694)>>2)]; + var $8696=(($8695)|0) < 0; + if ($8696) { __label__ = 345; break; } else { __label__ = 350; break; } + case 345: + var $8698=$newf5; + var $8699=(($8698)|0); + var $8700=HEAP32[(($8699)>>2)]; + var $8701=(((-$8700))|0); + $builtinnumber8=$8701; + var $8702=$builtinnumber8; + var $8703=$2; + var $8704=(($8703+132)|0); + var $8705=HEAP32[(($8704)>>2)]; + var $8706=(($8702)>>>0) < (($8705)>>>0); + if ($8706) { __label__ = 346; break; } else { __label__ = 348; break; } + case 346: + var $8708=$builtinnumber8; + var $8709=$2; + var $8710=(($8709+128)|0); + var $8711=HEAP32[(($8710)>>2)]; + var $8712=(($8711+($8708<<2))|0); + var $8713=HEAP32[(($8712)>>2)]; + var $8714=(($8713)|0)!=0; + if ($8714) { __label__ = 347; break; } else { __label__ = 348; break; } + case 347: + var $8716=$builtinnumber8; + var $8717=$2; + var $8718=(($8717+128)|0); + var $8719=HEAP32[(($8718)>>2)]; + var $8720=(($8719+($8716<<2))|0); + var $8721=HEAP32[(($8720)>>2)]; + var $8722=$2; + var $8723=FUNCTION_TABLE[$8721]($8722); + __label__ = 349; break; + case 348: + var $8725=$2; + var $8726=$builtinnumber8; + var $8727=$2; + var $8728=(($8727)|0); + var $8729=HEAP32[(($8728)>>2)]; + _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)); + __label__ = 349; break; + case 349: + __label__ = 351; break; + case 350: + var $8732=$2; + var $8733=(($8732+4)|0); + var $8734=HEAP32[(($8733)>>2)]; + var $8735=$2; + var $8736=$newf5; + var $8737=_prog_enterfunction($8735, $8736); + var $8738=(($8734+($8737<<3))|0); + var $8739=((($8738)-(8))|0); + $st=$8739; + __label__ = 351; break; + case 351: + var $8741=$2; + var $8742=(($8741+112)|0); + var $8743=HEAP32[(($8742)>>2)]; + var $8744=(($8743)|0)!=0; + if ($8744) { __label__ = 352; break; } else { __label__ = 353; break; } + case 352: + __label__ = 488; break; + case 353: + __label__ = 366; break; + case 354: + var $8748=$2; + var $8749=$2; + var $8750=(($8749)|0); + var $8751=HEAP32[(($8750)>>2)]; + _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)); + __label__ = 366; break; + case 355: + var $8753=$st; + var $8754=(($8753+2)|0); + var $8755=$8754; + var $8756=HEAP16[(($8755)>>1)]; + var $8757=(($8756 << 16) >> 16); + var $8758=((($8757)-(1))|0); + var $8759=$st; + var $8760=(($8759+($8758<<3))|0); + $st=$8760; + var $8761=$jumpcount; + var $8762=((($8761)+(1))|0); + $jumpcount=$8762; + var $8763=(($8762)|0)==10000000; + if ($8763) { __label__ = 356; break; } else { __label__ = 357; break; } + case 356: + var $8765=$2; + var $8766=$2; + var $8767=(($8766)|0); + var $8768=HEAP32[(($8767)>>2)]; + var $8769=$jumpcount; + _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)); + __label__ = 357; break; + case 357: + __label__ = 366; break; + case 358: + var $8772=$2; + var $8773=(($8772+64)|0); + var $8774=HEAP32[(($8773)>>2)]; + var $8775=$st; + var $8776=(($8775+2)|0); + var $8777=$8776; + var $8778=HEAP16[(($8777)>>1)]; + var $8779=(($8778)&65535); + var $8780=(($8774+($8779<<2))|0); + var $8781=$8780; + var $8782=$8781; + var $8783=HEAP32[(($8782)>>2)]; + var $8784=$8783 & 2147483647; + var $8785=(($8784)|0)!=0; + if ($8785) { __label__ = 359; break; } else { var $8802 = 0;__label__ = 360; break; } + case 359: + var $8787=$2; + var $8788=(($8787+64)|0); + var $8789=HEAP32[(($8788)>>2)]; + var $8790=$st; + var $8791=(($8790+4)|0); + var $8792=$8791; + var $8793=HEAP16[(($8792)>>1)]; + var $8794=(($8793)&65535); + var $8795=(($8789+($8794<<2))|0); + var $8796=$8795; + var $8797=$8796; + var $8798=HEAP32[(($8797)>>2)]; + var $8799=$8798 & 2147483647; + var $8800=(($8799)|0)!=0; + var $8802 = $8800;__label__ = 360; break; + case 360: + var $8802; + var $8803=(($8802)&1); + var $8804=(($8803)|0); + var $8805=$2; + var $8806=(($8805+64)|0); + var $8807=HEAP32[(($8806)>>2)]; + var $8808=$st; + var $8809=(($8808+6)|0); + var $8810=$8809; + var $8811=HEAP16[(($8810)>>1)]; + var $8812=(($8811)&65535); + var $8813=(($8807+($8812<<2))|0); + var $8814=$8813; + var $8815=$8814; + HEAPF32[(($8815)>>2)]=$8804; + __label__ = 366; break; + case 361: + var $8817=$2; + var $8818=(($8817+64)|0); + var $8819=HEAP32[(($8818)>>2)]; + var $8820=$st; + var $8821=(($8820+2)|0); + var $8822=$8821; + var $8823=HEAP16[(($8822)>>1)]; + var $8824=(($8823)&65535); + var $8825=(($8819+($8824<<2))|0); + var $8826=$8825; + var $8827=$8826; + var $8828=HEAP32[(($8827)>>2)]; + var $8829=$8828 & 2147483647; + var $8830=(($8829)|0)!=0; + if ($8830) { var $8847 = 1;__label__ = 363; break; } else { __label__ = 362; break; } + case 362: + var $8832=$2; + var $8833=(($8832+64)|0); + var $8834=HEAP32[(($8833)>>2)]; + var $8835=$st; + var $8836=(($8835+4)|0); + var $8837=$8836; + var $8838=HEAP16[(($8837)>>1)]; + var $8839=(($8838)&65535); + var $8840=(($8834+($8839<<2))|0); + var $8841=$8840; + var $8842=$8841; + var $8843=HEAP32[(($8842)>>2)]; + var $8844=$8843 & 2147483647; + var $8845=(($8844)|0)!=0; + var $8847 = $8845;__label__ = 363; break; + case 363: + var $8847; + var $8848=(($8847)&1); + var $8849=(($8848)|0); + var $8850=$2; + var $8851=(($8850+64)|0); + var $8852=HEAP32[(($8851)>>2)]; + var $8853=$st; + var $8854=(($8853+6)|0); + var $8855=$8854; + var $8856=HEAP16[(($8855)>>1)]; + var $8857=(($8856)&65535); + var $8858=(($8852+($8857<<2))|0); + var $8859=$8858; + var $8860=$8859; + HEAPF32[(($8860)>>2)]=$8849; + __label__ = 366; break; + case 364: + var $8862=$2; + var $8863=(($8862+64)|0); + var $8864=HEAP32[(($8863)>>2)]; + var $8865=$st; + var $8866=(($8865+2)|0); + var $8867=$8866; + var $8868=HEAP16[(($8867)>>1)]; + var $8869=(($8868)&65535); + var $8870=(($8864+($8869<<2))|0); + var $8871=$8870; + var $8872=$8871; + var $8873=HEAPF32[(($8872)>>2)]; + var $8874=(($8873)&-1); + var $8875=$2; + var $8876=(($8875+64)|0); + var $8877=HEAP32[(($8876)>>2)]; + var $8878=$st; + var $8879=(($8878+4)|0); + var $8880=$8879; + var $8881=HEAP16[(($8880)>>1)]; + var $8882=(($8881)&65535); + var $8883=(($8877+($8882<<2))|0); + var $8884=$8883; + var $8885=$8884; + var $8886=HEAPF32[(($8885)>>2)]; + var $8887=(($8886)&-1); + var $8888=$8874 & $8887; + var $8889=(($8888)|0); + var $8890=$2; + var $8891=(($8890+64)|0); + var $8892=HEAP32[(($8891)>>2)]; + var $8893=$st; + var $8894=(($8893+6)|0); + var $8895=$8894; + var $8896=HEAP16[(($8895)>>1)]; + var $8897=(($8896)&65535); + var $8898=(($8892+($8897<<2))|0); + var $8899=$8898; + var $8900=$8899; + HEAPF32[(($8900)>>2)]=$8889; + __label__ = 366; break; + case 365: + var $8902=$2; + var $8903=(($8902+64)|0); + var $8904=HEAP32[(($8903)>>2)]; + var $8905=$st; + var $8906=(($8905+2)|0); + var $8907=$8906; + var $8908=HEAP16[(($8907)>>1)]; + var $8909=(($8908)&65535); + var $8910=(($8904+($8909<<2))|0); + var $8911=$8910; + var $8912=$8911; + var $8913=HEAPF32[(($8912)>>2)]; + var $8914=(($8913)&-1); + var $8915=$2; + var $8916=(($8915+64)|0); + var $8917=HEAP32[(($8916)>>2)]; + var $8918=$st; + var $8919=(($8918+4)|0); + var $8920=$8919; + var $8921=HEAP16[(($8920)>>1)]; + var $8922=(($8921)&65535); + var $8923=(($8917+($8922<<2))|0); + var $8924=$8923; + var $8925=$8924; + var $8926=HEAPF32[(($8925)>>2)]; + var $8927=(($8926)&-1); + var $8928=$8914 | $8927; + var $8929=(($8928)|0); + var $8930=$2; + var $8931=(($8930+64)|0); + var $8932=HEAP32[(($8931)>>2)]; + var $8933=$st; + var $8934=(($8933+6)|0); + var $8935=$8934; + var $8936=HEAP16[(($8935)>>1)]; + var $8937=(($8936)&65535); + var $8938=(($8932+($8937<<2))|0); + var $8939=$8938; + var $8940=$8939; + HEAPF32[(($8940)>>2)]=$8929; + __label__ = 366; break; + case 366: + __label__ = 247; break; + case 367: + __label__ = 368; break; + case 368: + var $8944=$st; + var $8945=(($8944+8)|0); + $st=$8945; + var $8946=$st; + var $8947=$2; + var $8948=(($8947+4)|0); + var $8949=HEAP32[(($8948)>>2)]; + var $8950=$8946; + var $8951=$8949; + var $8952=((($8950)-($8951))|0); + var $8953=((((($8952)|0))/(8))&-1); + var $8954=$2; + var $8955=(($8954+116)|0); + var $8956=HEAP32[(($8955)>>2)]; + var $8957=(($8956+($8953<<2))|0); + var $8958=HEAP32[(($8957)>>2)]; + var $8959=((($8958)+(1))|0); + HEAP32[(($8957)>>2)]=$8959; + var $8960=$2; + var $8961=$st; + _prog_print_statement($8960, $8961); + var $8962=$st; + var $8963=(($8962)|0); + var $8964=HEAP16[(($8963)>>1)]; + var $8965=(($8964)&65535); + if ((($8965)|0) == 0 || (($8965)|0) == 43) { + __label__ = 370; break; + } + else if ((($8965)|0) == 1) { + __label__ = 373; break; + } + else if ((($8965)|0) == 2) { + __label__ = 374; break; + } + else if ((($8965)|0) == 3) { + __label__ = 375; break; + } + else if ((($8965)|0) == 4) { + __label__ = 376; break; + } + else if ((($8965)|0) == 5) { + __label__ = 377; break; + } + else if ((($8965)|0) == 6) { + __label__ = 381; break; + } + else if ((($8965)|0) == 7) { + __label__ = 382; break; + } + else if ((($8965)|0) == 8) { + __label__ = 383; break; + } + else if ((($8965)|0) == 9) { + __label__ = 384; break; + } + else if ((($8965)|0) == 10) { + __label__ = 385; break; + } + else if ((($8965)|0) == 11) { + __label__ = 386; break; + } + else if ((($8965)|0) == 12) { + __label__ = 390; break; + } + else if ((($8965)|0) == 13) { + __label__ = 391; break; + } + else if ((($8965)|0) == 14) { + __label__ = 392; break; + } + else if ((($8965)|0) == 15) { + __label__ = 393; break; + } + else if ((($8965)|0) == 16) { + __label__ = 394; break; + } + else if ((($8965)|0) == 17) { + __label__ = 398; break; + } + else if ((($8965)|0) == 18) { + __label__ = 399; break; + } + else if ((($8965)|0) == 19) { + __label__ = 400; break; + } + else if ((($8965)|0) == 20) { + __label__ = 401; break; + } + else if ((($8965)|0) == 21) { + __label__ = 402; break; + } + else if ((($8965)|0) == 22) { + __label__ = 403; break; + } + else if ((($8965)|0) == 23) { + __label__ = 404; break; + } + else if ((($8965)|0) == 24 || (($8965)|0) == 26 || (($8965)|0) == 28 || (($8965)|0) == 27 || (($8965)|0) == 29) { + __label__ = 405; break; + } + else if ((($8965)|0) == 25) { + __label__ = 411; break; + } + else if ((($8965)|0) == 30) { + __label__ = 418; break; + } + else if ((($8965)|0) == 31 || (($8965)|0) == 33 || (($8965)|0) == 34 || (($8965)|0) == 35 || (($8965)|0) == 36) { + __label__ = 424; break; + } + else if ((($8965)|0) == 32) { + __label__ = 425; break; + } + else if ((($8965)|0) == 37 || (($8965)|0) == 39 || (($8965)|0) == 40 || (($8965)|0) == 41 || (($8965)|0) == 42) { + __label__ = 426; break; + } + else if ((($8965)|0) == 38) { + __label__ = 433; break; + } + else if ((($8965)|0) == 44) { + __label__ = 440; break; + } + else if ((($8965)|0) == 45) { + __label__ = 441; break; + } + else if ((($8965)|0) == 46) { + __label__ = 445; break; + } + else if ((($8965)|0) == 47) { + __label__ = 448; break; + } + else if ((($8965)|0) == 48) { + __label__ = 449; break; + } + else if ((($8965)|0) == 49) { + __label__ = 450; break; + } + else if ((($8965)|0) == 50) { + __label__ = 455; break; + } + 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) { + __label__ = 460; break; + } + else if ((($8965)|0) == 60) { + __label__ = 475; break; + } + else if ((($8965)|0) == 61) { + __label__ = 476; break; + } + else if ((($8965)|0) == 62) { + __label__ = 479; break; + } + else if ((($8965)|0) == 63) { + __label__ = 482; break; + } + else if ((($8965)|0) == 64) { + __label__ = 485; break; + } + else if ((($8965)|0) == 65) { + __label__ = 486; break; + } + else { + __label__ = 369; break; + } + + case 369: + var $8967=$2; + var $8968=$2; + var $8969=(($8968)|0); + var $8970=HEAP32[(($8969)>>2)]; + _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)); + __label__ = 488; break; + case 370: + var $8972=$2; + var $8973=(($8972+64)|0); + var $8974=HEAP32[(($8973)>>2)]; + var $8975=$st; + var $8976=(($8975+2)|0); + var $8977=$8976; + var $8978=HEAP16[(($8977)>>1)]; + var $8979=(($8978)&65535); + var $8980=(($8974+($8979<<2))|0); + var $8981=$8980; + var $8982=$8981; + var $8983=(($8982)|0); + var $8984=HEAP32[(($8983)>>2)]; + var $8985=$2; + var $8986=(($8985+64)|0); + var $8987=HEAP32[(($8986)>>2)]; + var $8988=(($8987+4)|0); + var $8989=$8988; + var $8990=$8989; + var $8991=(($8990)|0); + HEAP32[(($8991)>>2)]=$8984; + var $8992=$2; + var $8993=(($8992+64)|0); + var $8994=HEAP32[(($8993)>>2)]; + var $8995=$st; + var $8996=(($8995+2)|0); + var $8997=$8996; + var $8998=HEAP16[(($8997)>>1)]; + var $8999=(($8998)&65535); + var $9000=(($8994+($8999<<2))|0); + var $9001=$9000; + var $9002=$9001; + var $9003=(($9002+4)|0); + var $9004=HEAP32[(($9003)>>2)]; + var $9005=$2; + var $9006=(($9005+64)|0); + var $9007=HEAP32[(($9006)>>2)]; + var $9008=(($9007+4)|0); + var $9009=$9008; + var $9010=$9009; + var $9011=(($9010+4)|0); + HEAP32[(($9011)>>2)]=$9004; + var $9012=$2; + var $9013=(($9012+64)|0); + var $9014=HEAP32[(($9013)>>2)]; + var $9015=$st; + var $9016=(($9015+2)|0); + var $9017=$9016; + var $9018=HEAP16[(($9017)>>1)]; + var $9019=(($9018)&65535); + var $9020=(($9014+($9019<<2))|0); + var $9021=$9020; + var $9022=$9021; + var $9023=(($9022+8)|0); + var $9024=HEAP32[(($9023)>>2)]; + var $9025=$2; + var $9026=(($9025+64)|0); + var $9027=HEAP32[(($9026)>>2)]; + var $9028=(($9027+4)|0); + var $9029=$9028; + var $9030=$9029; + var $9031=(($9030+8)|0); + HEAP32[(($9031)>>2)]=$9024; + var $9032=$2; + var $9033=(($9032+4)|0); + var $9034=HEAP32[(($9033)>>2)]; + var $9035=$2; + var $9036=_prog_leavefunction($9035); + var $9037=(($9034+($9036<<3))|0); + $st=$9037; + var $9038=$2; + var $9039=(($9038+168)|0); + var $9040=HEAP32[(($9039)>>2)]; + var $9041=(($9040)|0)!=0; + if ($9041) { __label__ = 372; break; } else { __label__ = 371; break; } + case 371: + __label__ = 488; break; + case 372: + __label__ = 487; break; + case 373: + var $9045=$2; + var $9046=(($9045+64)|0); + var $9047=HEAP32[(($9046)>>2)]; + var $9048=$st; + var $9049=(($9048+2)|0); + var $9050=$9049; + var $9051=HEAP16[(($9050)>>1)]; + var $9052=(($9051)&65535); + var $9053=(($9047+($9052<<2))|0); + var $9054=$9053; + var $9055=$9054; + var $9056=HEAPF32[(($9055)>>2)]; + var $9057=$2; + var $9058=(($9057+64)|0); + var $9059=HEAP32[(($9058)>>2)]; + var $9060=$st; + var $9061=(($9060+4)|0); + var $9062=$9061; + var $9063=HEAP16[(($9062)>>1)]; + var $9064=(($9063)&65535); + var $9065=(($9059+($9064<<2))|0); + var $9066=$9065; + var $9067=$9066; + var $9068=HEAPF32[(($9067)>>2)]; + var $9069=($9056)*($9068); + var $9070=$2; + var $9071=(($9070+64)|0); + var $9072=HEAP32[(($9071)>>2)]; + var $9073=$st; + var $9074=(($9073+6)|0); + var $9075=$9074; + var $9076=HEAP16[(($9075)>>1)]; + var $9077=(($9076)&65535); + var $9078=(($9072+($9077<<2))|0); + var $9079=$9078; + var $9080=$9079; + HEAPF32[(($9080)>>2)]=$9069; + __label__ = 487; break; + case 374: + var $9082=$2; + var $9083=(($9082+64)|0); + var $9084=HEAP32[(($9083)>>2)]; + var $9085=$st; + var $9086=(($9085+2)|0); + var $9087=$9086; + var $9088=HEAP16[(($9087)>>1)]; + var $9089=(($9088)&65535); + var $9090=(($9084+($9089<<2))|0); + var $9091=$9090; + var $9092=$9091; + var $9093=(($9092)|0); + var $9094=HEAPF32[(($9093)>>2)]; + var $9095=$2; + var $9096=(($9095+64)|0); + var $9097=HEAP32[(($9096)>>2)]; + var $9098=$st; + var $9099=(($9098+4)|0); + var $9100=$9099; + var $9101=HEAP16[(($9100)>>1)]; + var $9102=(($9101)&65535); + var $9103=(($9097+($9102<<2))|0); + var $9104=$9103; + var $9105=$9104; + var $9106=(($9105)|0); + var $9107=HEAPF32[(($9106)>>2)]; + var $9108=($9094)*($9107); + var $9109=$2; + var $9110=(($9109+64)|0); + var $9111=HEAP32[(($9110)>>2)]; + var $9112=$st; + var $9113=(($9112+2)|0); + var $9114=$9113; + var $9115=HEAP16[(($9114)>>1)]; + var $9116=(($9115)&65535); + var $9117=(($9111+($9116<<2))|0); + var $9118=$9117; + var $9119=$9118; + var $9120=(($9119+4)|0); + var $9121=HEAPF32[(($9120)>>2)]; + var $9122=$2; + var $9123=(($9122+64)|0); + var $9124=HEAP32[(($9123)>>2)]; + var $9125=$st; + var $9126=(($9125+4)|0); + var $9127=$9126; + var $9128=HEAP16[(($9127)>>1)]; + var $9129=(($9128)&65535); + var $9130=(($9124+($9129<<2))|0); + var $9131=$9130; + var $9132=$9131; + var $9133=(($9132+4)|0); + var $9134=HEAPF32[(($9133)>>2)]; + var $9135=($9121)*($9134); + var $9136=($9108)+($9135); + var $9137=$2; + var $9138=(($9137+64)|0); + var $9139=HEAP32[(($9138)>>2)]; + var $9140=$st; + var $9141=(($9140+2)|0); + var $9142=$9141; + var $9143=HEAP16[(($9142)>>1)]; + var $9144=(($9143)&65535); + var $9145=(($9139+($9144<<2))|0); + var $9146=$9145; + var $9147=$9146; + var $9148=(($9147+8)|0); + var $9149=HEAPF32[(($9148)>>2)]; + var $9150=$2; + var $9151=(($9150+64)|0); + var $9152=HEAP32[(($9151)>>2)]; + var $9153=$st; + var $9154=(($9153+4)|0); + var $9155=$9154; + var $9156=HEAP16[(($9155)>>1)]; + var $9157=(($9156)&65535); + var $9158=(($9152+($9157<<2))|0); + var $9159=$9158; + var $9160=$9159; + var $9161=(($9160+8)|0); + var $9162=HEAPF32[(($9161)>>2)]; + var $9163=($9149)*($9162); + var $9164=($9136)+($9163); + var $9165=$2; + var $9166=(($9165+64)|0); + var $9167=HEAP32[(($9166)>>2)]; + var $9168=$st; + var $9169=(($9168+6)|0); + var $9170=$9169; + var $9171=HEAP16[(($9170)>>1)]; + var $9172=(($9171)&65535); + var $9173=(($9167+($9172<<2))|0); + var $9174=$9173; + var $9175=$9174; + HEAPF32[(($9175)>>2)]=$9164; + __label__ = 487; break; + case 375: + var $9177=$2; + var $9178=(($9177+64)|0); + var $9179=HEAP32[(($9178)>>2)]; + var $9180=$st; + var $9181=(($9180+2)|0); + var $9182=$9181; + var $9183=HEAP16[(($9182)>>1)]; + var $9184=(($9183)&65535); + var $9185=(($9179+($9184<<2))|0); + var $9186=$9185; + var $9187=$9186; + var $9188=HEAPF32[(($9187)>>2)]; + var $9189=$2; + var $9190=(($9189+64)|0); + var $9191=HEAP32[(($9190)>>2)]; + var $9192=$st; + var $9193=(($9192+4)|0); + var $9194=$9193; + var $9195=HEAP16[(($9194)>>1)]; + var $9196=(($9195)&65535); + var $9197=(($9191+($9196<<2))|0); + var $9198=$9197; + var $9199=$9198; + var $9200=(($9199)|0); + var $9201=HEAPF32[(($9200)>>2)]; + var $9202=($9188)*($9201); + var $9203=$2; + var $9204=(($9203+64)|0); + var $9205=HEAP32[(($9204)>>2)]; + var $9206=$st; + var $9207=(($9206+6)|0); + var $9208=$9207; + var $9209=HEAP16[(($9208)>>1)]; + var $9210=(($9209)&65535); + var $9211=(($9205+($9210<<2))|0); + var $9212=$9211; + var $9213=$9212; + var $9214=(($9213)|0); + HEAPF32[(($9214)>>2)]=$9202; + var $9215=$2; + var $9216=(($9215+64)|0); + var $9217=HEAP32[(($9216)>>2)]; + var $9218=$st; + var $9219=(($9218+2)|0); + var $9220=$9219; + var $9221=HEAP16[(($9220)>>1)]; + var $9222=(($9221)&65535); + var $9223=(($9217+($9222<<2))|0); + var $9224=$9223; + var $9225=$9224; + var $9226=HEAPF32[(($9225)>>2)]; + var $9227=$2; + var $9228=(($9227+64)|0); + var $9229=HEAP32[(($9228)>>2)]; + var $9230=$st; + var $9231=(($9230+4)|0); + var $9232=$9231; + var $9233=HEAP16[(($9232)>>1)]; + var $9234=(($9233)&65535); + var $9235=(($9229+($9234<<2))|0); + var $9236=$9235; + var $9237=$9236; + var $9238=(($9237+4)|0); + var $9239=HEAPF32[(($9238)>>2)]; + var $9240=($9226)*($9239); + var $9241=$2; + var $9242=(($9241+64)|0); + var $9243=HEAP32[(($9242)>>2)]; + var $9244=$st; + var $9245=(($9244+6)|0); + var $9246=$9245; + var $9247=HEAP16[(($9246)>>1)]; + var $9248=(($9247)&65535); + var $9249=(($9243+($9248<<2))|0); + var $9250=$9249; + var $9251=$9250; + var $9252=(($9251+4)|0); + HEAPF32[(($9252)>>2)]=$9240; + var $9253=$2; + var $9254=(($9253+64)|0); + var $9255=HEAP32[(($9254)>>2)]; + var $9256=$st; + var $9257=(($9256+2)|0); + var $9258=$9257; + var $9259=HEAP16[(($9258)>>1)]; + var $9260=(($9259)&65535); + var $9261=(($9255+($9260<<2))|0); + var $9262=$9261; + var $9263=$9262; + var $9264=HEAPF32[(($9263)>>2)]; + var $9265=$2; + var $9266=(($9265+64)|0); + var $9267=HEAP32[(($9266)>>2)]; + var $9268=$st; + var $9269=(($9268+4)|0); + var $9270=$9269; + var $9271=HEAP16[(($9270)>>1)]; + var $9272=(($9271)&65535); + var $9273=(($9267+($9272<<2))|0); + var $9274=$9273; + var $9275=$9274; + var $9276=(($9275+8)|0); + var $9277=HEAPF32[(($9276)>>2)]; + var $9278=($9264)*($9277); + var $9279=$2; + var $9280=(($9279+64)|0); + var $9281=HEAP32[(($9280)>>2)]; + var $9282=$st; + var $9283=(($9282+6)|0); + var $9284=$9283; + var $9285=HEAP16[(($9284)>>1)]; + var $9286=(($9285)&65535); + var $9287=(($9281+($9286<<2))|0); + var $9288=$9287; + var $9289=$9288; + var $9290=(($9289+8)|0); + HEAPF32[(($9290)>>2)]=$9278; + __label__ = 487; break; + case 376: + var $9292=$2; + var $9293=(($9292+64)|0); + var $9294=HEAP32[(($9293)>>2)]; + var $9295=$st; + var $9296=(($9295+4)|0); + var $9297=$9296; + var $9298=HEAP16[(($9297)>>1)]; + var $9299=(($9298)&65535); + var $9300=(($9294+($9299<<2))|0); + var $9301=$9300; + var $9302=$9301; + var $9303=HEAPF32[(($9302)>>2)]; + var $9304=$2; + var $9305=(($9304+64)|0); + var $9306=HEAP32[(($9305)>>2)]; + var $9307=$st; + var $9308=(($9307+2)|0); + var $9309=$9308; + var $9310=HEAP16[(($9309)>>1)]; + var $9311=(($9310)&65535); + var $9312=(($9306+($9311<<2))|0); + var $9313=$9312; + var $9314=$9313; + var $9315=(($9314)|0); + var $9316=HEAPF32[(($9315)>>2)]; + var $9317=($9303)*($9316); + var $9318=$2; + var $9319=(($9318+64)|0); + var $9320=HEAP32[(($9319)>>2)]; + var $9321=$st; + var $9322=(($9321+6)|0); + var $9323=$9322; + var $9324=HEAP16[(($9323)>>1)]; + var $9325=(($9324)&65535); + var $9326=(($9320+($9325<<2))|0); + var $9327=$9326; + var $9328=$9327; + var $9329=(($9328)|0); + HEAPF32[(($9329)>>2)]=$9317; + var $9330=$2; + var $9331=(($9330+64)|0); + var $9332=HEAP32[(($9331)>>2)]; + var $9333=$st; + var $9334=(($9333+4)|0); + var $9335=$9334; + var $9336=HEAP16[(($9335)>>1)]; + var $9337=(($9336)&65535); + var $9338=(($9332+($9337<<2))|0); + var $9339=$9338; + var $9340=$9339; + var $9341=HEAPF32[(($9340)>>2)]; + var $9342=$2; + var $9343=(($9342+64)|0); + var $9344=HEAP32[(($9343)>>2)]; + var $9345=$st; + var $9346=(($9345+2)|0); + var $9347=$9346; + var $9348=HEAP16[(($9347)>>1)]; + var $9349=(($9348)&65535); + var $9350=(($9344+($9349<<2))|0); + var $9351=$9350; + var $9352=$9351; + var $9353=(($9352+4)|0); + var $9354=HEAPF32[(($9353)>>2)]; + var $9355=($9341)*($9354); + var $9356=$2; + var $9357=(($9356+64)|0); + var $9358=HEAP32[(($9357)>>2)]; + var $9359=$st; + var $9360=(($9359+6)|0); + var $9361=$9360; + var $9362=HEAP16[(($9361)>>1)]; + var $9363=(($9362)&65535); + var $9364=(($9358+($9363<<2))|0); + var $9365=$9364; + var $9366=$9365; + var $9367=(($9366+4)|0); + HEAPF32[(($9367)>>2)]=$9355; + var $9368=$2; + var $9369=(($9368+64)|0); + var $9370=HEAP32[(($9369)>>2)]; + var $9371=$st; + var $9372=(($9371+4)|0); + var $9373=$9372; + var $9374=HEAP16[(($9373)>>1)]; + var $9375=(($9374)&65535); + var $9376=(($9370+($9375<<2))|0); + var $9377=$9376; + var $9378=$9377; + var $9379=HEAPF32[(($9378)>>2)]; + var $9380=$2; + var $9381=(($9380+64)|0); + var $9382=HEAP32[(($9381)>>2)]; + var $9383=$st; + var $9384=(($9383+2)|0); + var $9385=$9384; + var $9386=HEAP16[(($9385)>>1)]; + var $9387=(($9386)&65535); + var $9388=(($9382+($9387<<2))|0); + var $9389=$9388; + var $9390=$9389; + var $9391=(($9390+8)|0); + var $9392=HEAPF32[(($9391)>>2)]; + var $9393=($9379)*($9392); + var $9394=$2; + var $9395=(($9394+64)|0); + var $9396=HEAP32[(($9395)>>2)]; + var $9397=$st; + var $9398=(($9397+6)|0); + var $9399=$9398; + var $9400=HEAP16[(($9399)>>1)]; + var $9401=(($9400)&65535); + var $9402=(($9396+($9401<<2))|0); + var $9403=$9402; + var $9404=$9403; + var $9405=(($9404+8)|0); + HEAPF32[(($9405)>>2)]=$9393; + __label__ = 487; break; + case 377: + var $9407=$2; + var $9408=(($9407+64)|0); + var $9409=HEAP32[(($9408)>>2)]; + var $9410=$st; + var $9411=(($9410+4)|0); + var $9412=$9411; + var $9413=HEAP16[(($9412)>>1)]; + var $9414=(($9413)&65535); + var $9415=(($9409+($9414<<2))|0); + var $9416=$9415; + var $9417=$9416; + var $9418=HEAPF32[(($9417)>>2)]; + var $9419=$9418 != 0; + if ($9419) { __label__ = 378; break; } else { __label__ = 379; break; } + case 378: + var $9421=$2; + var $9422=(($9421+64)|0); + var $9423=HEAP32[(($9422)>>2)]; + var $9424=$st; + var $9425=(($9424+2)|0); + var $9426=$9425; + var $9427=HEAP16[(($9426)>>1)]; + var $9428=(($9427)&65535); + var $9429=(($9423+($9428<<2))|0); + var $9430=$9429; + var $9431=$9430; + var $9432=HEAPF32[(($9431)>>2)]; + var $9433=$2; + var $9434=(($9433+64)|0); + var $9435=HEAP32[(($9434)>>2)]; + var $9436=$st; + var $9437=(($9436+4)|0); + var $9438=$9437; + var $9439=HEAP16[(($9438)>>1)]; + var $9440=(($9439)&65535); + var $9441=(($9435+($9440<<2))|0); + var $9442=$9441; + var $9443=$9442; + var $9444=HEAPF32[(($9443)>>2)]; + var $9445=($9432)/($9444); + var $9446=$2; + var $9447=(($9446+64)|0); + var $9448=HEAP32[(($9447)>>2)]; + var $9449=$st; + var $9450=(($9449+6)|0); + var $9451=$9450; + var $9452=HEAP16[(($9451)>>1)]; + var $9453=(($9452)&65535); + var $9454=(($9448+($9453<<2))|0); + var $9455=$9454; + var $9456=$9455; + HEAPF32[(($9456)>>2)]=$9445; + __label__ = 380; break; + case 379: + var $9458=$2; + var $9459=(($9458+64)|0); + var $9460=HEAP32[(($9459)>>2)]; + var $9461=$st; + var $9462=(($9461+6)|0); + var $9463=$9462; + var $9464=HEAP16[(($9463)>>1)]; + var $9465=(($9464)&65535); + var $9466=(($9460+($9465<<2))|0); + var $9467=$9466; + var $9468=$9467; + HEAPF32[(($9468)>>2)]=0; + __label__ = 380; break; + case 380: + __label__ = 487; break; + case 381: + var $9471=$2; + var $9472=(($9471+64)|0); + var $9473=HEAP32[(($9472)>>2)]; + var $9474=$st; + var $9475=(($9474+2)|0); + var $9476=$9475; + var $9477=HEAP16[(($9476)>>1)]; + var $9478=(($9477)&65535); + var $9479=(($9473+($9478<<2))|0); + var $9480=$9479; + var $9481=$9480; + var $9482=HEAPF32[(($9481)>>2)]; + var $9483=$2; + var $9484=(($9483+64)|0); + var $9485=HEAP32[(($9484)>>2)]; + var $9486=$st; + var $9487=(($9486+4)|0); + var $9488=$9487; + var $9489=HEAP16[(($9488)>>1)]; + var $9490=(($9489)&65535); + var $9491=(($9485+($9490<<2))|0); + var $9492=$9491; + var $9493=$9492; + var $9494=HEAPF32[(($9493)>>2)]; + var $9495=($9482)+($9494); + var $9496=$2; + var $9497=(($9496+64)|0); + var $9498=HEAP32[(($9497)>>2)]; + var $9499=$st; + var $9500=(($9499+6)|0); + var $9501=$9500; + var $9502=HEAP16[(($9501)>>1)]; + var $9503=(($9502)&65535); + var $9504=(($9498+($9503<<2))|0); + var $9505=$9504; + var $9506=$9505; + HEAPF32[(($9506)>>2)]=$9495; + __label__ = 487; break; + case 382: + var $9508=$2; + var $9509=(($9508+64)|0); + var $9510=HEAP32[(($9509)>>2)]; + var $9511=$st; + var $9512=(($9511+2)|0); + var $9513=$9512; + var $9514=HEAP16[(($9513)>>1)]; + var $9515=(($9514)&65535); + var $9516=(($9510+($9515<<2))|0); + var $9517=$9516; + var $9518=$9517; + var $9519=(($9518)|0); + var $9520=HEAPF32[(($9519)>>2)]; + var $9521=$2; + var $9522=(($9521+64)|0); + var $9523=HEAP32[(($9522)>>2)]; + var $9524=$st; + var $9525=(($9524+4)|0); + var $9526=$9525; + var $9527=HEAP16[(($9526)>>1)]; + var $9528=(($9527)&65535); + var $9529=(($9523+($9528<<2))|0); + var $9530=$9529; + var $9531=$9530; + var $9532=(($9531)|0); + var $9533=HEAPF32[(($9532)>>2)]; + var $9534=($9520)+($9533); + var $9535=$2; + var $9536=(($9535+64)|0); + var $9537=HEAP32[(($9536)>>2)]; + var $9538=$st; + var $9539=(($9538+6)|0); + var $9540=$9539; + var $9541=HEAP16[(($9540)>>1)]; + var $9542=(($9541)&65535); + var $9543=(($9537+($9542<<2))|0); + var $9544=$9543; + var $9545=$9544; + var $9546=(($9545)|0); + HEAPF32[(($9546)>>2)]=$9534; + var $9547=$2; + var $9548=(($9547+64)|0); + var $9549=HEAP32[(($9548)>>2)]; + var $9550=$st; + var $9551=(($9550+2)|0); + var $9552=$9551; + var $9553=HEAP16[(($9552)>>1)]; + var $9554=(($9553)&65535); + var $9555=(($9549+($9554<<2))|0); + var $9556=$9555; + var $9557=$9556; + var $9558=(($9557+4)|0); + var $9559=HEAPF32[(($9558)>>2)]; + var $9560=$2; + var $9561=(($9560+64)|0); + var $9562=HEAP32[(($9561)>>2)]; + var $9563=$st; + var $9564=(($9563+4)|0); + var $9565=$9564; + var $9566=HEAP16[(($9565)>>1)]; + var $9567=(($9566)&65535); + var $9568=(($9562+($9567<<2))|0); + var $9569=$9568; + var $9570=$9569; + var $9571=(($9570+4)|0); + var $9572=HEAPF32[(($9571)>>2)]; + var $9573=($9559)+($9572); + var $9574=$2; + var $9575=(($9574+64)|0); + var $9576=HEAP32[(($9575)>>2)]; + var $9577=$st; + var $9578=(($9577+6)|0); + var $9579=$9578; + var $9580=HEAP16[(($9579)>>1)]; + var $9581=(($9580)&65535); + var $9582=(($9576+($9581<<2))|0); + var $9583=$9582; + var $9584=$9583; + var $9585=(($9584+4)|0); + HEAPF32[(($9585)>>2)]=$9573; + var $9586=$2; + var $9587=(($9586+64)|0); + var $9588=HEAP32[(($9587)>>2)]; + var $9589=$st; + var $9590=(($9589+2)|0); + var $9591=$9590; + var $9592=HEAP16[(($9591)>>1)]; + var $9593=(($9592)&65535); + var $9594=(($9588+($9593<<2))|0); + var $9595=$9594; + var $9596=$9595; + var $9597=(($9596+8)|0); + var $9598=HEAPF32[(($9597)>>2)]; + var $9599=$2; + var $9600=(($9599+64)|0); + var $9601=HEAP32[(($9600)>>2)]; + var $9602=$st; + var $9603=(($9602+4)|0); + var $9604=$9603; + var $9605=HEAP16[(($9604)>>1)]; + var $9606=(($9605)&65535); + var $9607=(($9601+($9606<<2))|0); + var $9608=$9607; + var $9609=$9608; + var $9610=(($9609+8)|0); + var $9611=HEAPF32[(($9610)>>2)]; + var $9612=($9598)+($9611); + var $9613=$2; + var $9614=(($9613+64)|0); + var $9615=HEAP32[(($9614)>>2)]; + var $9616=$st; + var $9617=(($9616+6)|0); + var $9618=$9617; + var $9619=HEAP16[(($9618)>>1)]; + var $9620=(($9619)&65535); + var $9621=(($9615+($9620<<2))|0); + var $9622=$9621; + var $9623=$9622; + var $9624=(($9623+8)|0); + HEAPF32[(($9624)>>2)]=$9612; + __label__ = 487; break; + case 383: + var $9626=$2; + var $9627=(($9626+64)|0); + var $9628=HEAP32[(($9627)>>2)]; + var $9629=$st; + var $9630=(($9629+2)|0); + var $9631=$9630; + var $9632=HEAP16[(($9631)>>1)]; + var $9633=(($9632)&65535); + var $9634=(($9628+($9633<<2))|0); + var $9635=$9634; + var $9636=$9635; + var $9637=HEAPF32[(($9636)>>2)]; + var $9638=$2; + var $9639=(($9638+64)|0); + var $9640=HEAP32[(($9639)>>2)]; + var $9641=$st; + var $9642=(($9641+4)|0); + var $9643=$9642; + var $9644=HEAP16[(($9643)>>1)]; + var $9645=(($9644)&65535); + var $9646=(($9640+($9645<<2))|0); + var $9647=$9646; + var $9648=$9647; + var $9649=HEAPF32[(($9648)>>2)]; + var $9650=($9637)-($9649); + var $9651=$2; + var $9652=(($9651+64)|0); + var $9653=HEAP32[(($9652)>>2)]; + var $9654=$st; + var $9655=(($9654+6)|0); + var $9656=$9655; + var $9657=HEAP16[(($9656)>>1)]; + var $9658=(($9657)&65535); + var $9659=(($9653+($9658<<2))|0); + var $9660=$9659; + var $9661=$9660; + HEAPF32[(($9661)>>2)]=$9650; + __label__ = 487; break; + case 384: + var $9663=$2; + var $9664=(($9663+64)|0); + var $9665=HEAP32[(($9664)>>2)]; + var $9666=$st; + var $9667=(($9666+2)|0); + var $9668=$9667; + var $9669=HEAP16[(($9668)>>1)]; + var $9670=(($9669)&65535); + var $9671=(($9665+($9670<<2))|0); + var $9672=$9671; + var $9673=$9672; + var $9674=(($9673)|0); + var $9675=HEAPF32[(($9674)>>2)]; + var $9676=$2; + var $9677=(($9676+64)|0); + var $9678=HEAP32[(($9677)>>2)]; + var $9679=$st; + var $9680=(($9679+4)|0); + var $9681=$9680; + var $9682=HEAP16[(($9681)>>1)]; + var $9683=(($9682)&65535); + var $9684=(($9678+($9683<<2))|0); + var $9685=$9684; + var $9686=$9685; + var $9687=(($9686)|0); + var $9688=HEAPF32[(($9687)>>2)]; + var $9689=($9675)-($9688); + var $9690=$2; + var $9691=(($9690+64)|0); + var $9692=HEAP32[(($9691)>>2)]; + var $9693=$st; + var $9694=(($9693+6)|0); + var $9695=$9694; + var $9696=HEAP16[(($9695)>>1)]; + var $9697=(($9696)&65535); + var $9698=(($9692+($9697<<2))|0); + var $9699=$9698; + var $9700=$9699; + var $9701=(($9700)|0); + HEAPF32[(($9701)>>2)]=$9689; + var $9702=$2; + var $9703=(($9702+64)|0); + var $9704=HEAP32[(($9703)>>2)]; + var $9705=$st; + var $9706=(($9705+2)|0); + var $9707=$9706; + var $9708=HEAP16[(($9707)>>1)]; + var $9709=(($9708)&65535); + var $9710=(($9704+($9709<<2))|0); + var $9711=$9710; + var $9712=$9711; + var $9713=(($9712+4)|0); + var $9714=HEAPF32[(($9713)>>2)]; + var $9715=$2; + var $9716=(($9715+64)|0); + var $9717=HEAP32[(($9716)>>2)]; + var $9718=$st; + var $9719=(($9718+4)|0); + var $9720=$9719; + var $9721=HEAP16[(($9720)>>1)]; + var $9722=(($9721)&65535); + var $9723=(($9717+($9722<<2))|0); + var $9724=$9723; + var $9725=$9724; + var $9726=(($9725+4)|0); + var $9727=HEAPF32[(($9726)>>2)]; + var $9728=($9714)-($9727); + var $9729=$2; + var $9730=(($9729+64)|0); + var $9731=HEAP32[(($9730)>>2)]; + var $9732=$st; + var $9733=(($9732+6)|0); + var $9734=$9733; + var $9735=HEAP16[(($9734)>>1)]; + var $9736=(($9735)&65535); + var $9737=(($9731+($9736<<2))|0); + var $9738=$9737; + var $9739=$9738; + var $9740=(($9739+4)|0); + HEAPF32[(($9740)>>2)]=$9728; + var $9741=$2; + var $9742=(($9741+64)|0); + var $9743=HEAP32[(($9742)>>2)]; + var $9744=$st; + var $9745=(($9744+2)|0); + var $9746=$9745; + var $9747=HEAP16[(($9746)>>1)]; + var $9748=(($9747)&65535); + var $9749=(($9743+($9748<<2))|0); + var $9750=$9749; + var $9751=$9750; + var $9752=(($9751+8)|0); + var $9753=HEAPF32[(($9752)>>2)]; + var $9754=$2; + var $9755=(($9754+64)|0); + var $9756=HEAP32[(($9755)>>2)]; + var $9757=$st; + var $9758=(($9757+4)|0); + var $9759=$9758; + var $9760=HEAP16[(($9759)>>1)]; + var $9761=(($9760)&65535); + var $9762=(($9756+($9761<<2))|0); + var $9763=$9762; + var $9764=$9763; + var $9765=(($9764+8)|0); + var $9766=HEAPF32[(($9765)>>2)]; + var $9767=($9753)-($9766); + var $9768=$2; + var $9769=(($9768+64)|0); + var $9770=HEAP32[(($9769)>>2)]; + var $9771=$st; + var $9772=(($9771+6)|0); + var $9773=$9772; + var $9774=HEAP16[(($9773)>>1)]; + var $9775=(($9774)&65535); + var $9776=(($9770+($9775<<2))|0); + var $9777=$9776; + var $9778=$9777; + var $9779=(($9778+8)|0); + HEAPF32[(($9779)>>2)]=$9767; + __label__ = 487; break; + case 385: + var $9781=$2; + var $9782=(($9781+64)|0); + var $9783=HEAP32[(($9782)>>2)]; + var $9784=$st; + var $9785=(($9784+2)|0); + var $9786=$9785; + var $9787=HEAP16[(($9786)>>1)]; + var $9788=(($9787)&65535); + var $9789=(($9783+($9788<<2))|0); + var $9790=$9789; + var $9791=$9790; + var $9792=HEAPF32[(($9791)>>2)]; + var $9793=$2; + var $9794=(($9793+64)|0); + var $9795=HEAP32[(($9794)>>2)]; + var $9796=$st; + var $9797=(($9796+4)|0); + var $9798=$9797; + var $9799=HEAP16[(($9798)>>1)]; + var $9800=(($9799)&65535); + var $9801=(($9795+($9800<<2))|0); + var $9802=$9801; + var $9803=$9802; + var $9804=HEAPF32[(($9803)>>2)]; + var $9805=$9792 == $9804; + var $9806=(($9805)&1); + var $9807=(($9806)|0); + var $9808=$2; + var $9809=(($9808+64)|0); + var $9810=HEAP32[(($9809)>>2)]; + var $9811=$st; + var $9812=(($9811+6)|0); + var $9813=$9812; + var $9814=HEAP16[(($9813)>>1)]; + var $9815=(($9814)&65535); + var $9816=(($9810+($9815<<2))|0); + var $9817=$9816; + var $9818=$9817; + HEAPF32[(($9818)>>2)]=$9807; + __label__ = 487; break; + case 386: + var $9820=$2; + var $9821=(($9820+64)|0); + var $9822=HEAP32[(($9821)>>2)]; + var $9823=$st; + var $9824=(($9823+2)|0); + var $9825=$9824; + var $9826=HEAP16[(($9825)>>1)]; + var $9827=(($9826)&65535); + var $9828=(($9822+($9827<<2))|0); + var $9829=$9828; + var $9830=$9829; + var $9831=(($9830)|0); + var $9832=HEAPF32[(($9831)>>2)]; + var $9833=$2; + var $9834=(($9833+64)|0); + var $9835=HEAP32[(($9834)>>2)]; + var $9836=$st; + var $9837=(($9836+4)|0); + var $9838=$9837; + var $9839=HEAP16[(($9838)>>1)]; + var $9840=(($9839)&65535); + var $9841=(($9835+($9840<<2))|0); + var $9842=$9841; + var $9843=$9842; + var $9844=(($9843)|0); + var $9845=HEAPF32[(($9844)>>2)]; + var $9846=$9832 == $9845; + if ($9846) { __label__ = 387; break; } else { var $9904 = 0;__label__ = 389; break; } + case 387: + var $9848=$2; + var $9849=(($9848+64)|0); + var $9850=HEAP32[(($9849)>>2)]; + var $9851=$st; + var $9852=(($9851+2)|0); + var $9853=$9852; + var $9854=HEAP16[(($9853)>>1)]; + var $9855=(($9854)&65535); + var $9856=(($9850+($9855<<2))|0); + var $9857=$9856; + var $9858=$9857; + var $9859=(($9858+4)|0); + var $9860=HEAPF32[(($9859)>>2)]; + var $9861=$2; + var $9862=(($9861+64)|0); + var $9863=HEAP32[(($9862)>>2)]; + var $9864=$st; + var $9865=(($9864+4)|0); + var $9866=$9865; + var $9867=HEAP16[(($9866)>>1)]; + var $9868=(($9867)&65535); + var $9869=(($9863+($9868<<2))|0); + var $9870=$9869; + var $9871=$9870; + var $9872=(($9871+4)|0); + var $9873=HEAPF32[(($9872)>>2)]; + var $9874=$9860 == $9873; + if ($9874) { __label__ = 388; break; } else { var $9904 = 0;__label__ = 389; break; } + case 388: + var $9876=$2; + var $9877=(($9876+64)|0); + var $9878=HEAP32[(($9877)>>2)]; + var $9879=$st; + var $9880=(($9879+2)|0); + var $9881=$9880; + var $9882=HEAP16[(($9881)>>1)]; + var $9883=(($9882)&65535); + var $9884=(($9878+($9883<<2))|0); + var $9885=$9884; + var $9886=$9885; + var $9887=(($9886+8)|0); + var $9888=HEAPF32[(($9887)>>2)]; + var $9889=$2; + var $9890=(($9889+64)|0); + var $9891=HEAP32[(($9890)>>2)]; + var $9892=$st; + var $9893=(($9892+4)|0); + var $9894=$9893; + var $9895=HEAP16[(($9894)>>1)]; + var $9896=(($9895)&65535); + var $9897=(($9891+($9896<<2))|0); + var $9898=$9897; + var $9899=$9898; + var $9900=(($9899+8)|0); + var $9901=HEAPF32[(($9900)>>2)]; + var $9902=$9888 == $9901; + var $9904 = $9902;__label__ = 389; break; + case 389: + var $9904; + var $9905=(($9904)&1); + var $9906=(($9905)|0); + var $9907=$2; + var $9908=(($9907+64)|0); + var $9909=HEAP32[(($9908)>>2)]; + var $9910=$st; + var $9911=(($9910+6)|0); + var $9912=$9911; + var $9913=HEAP16[(($9912)>>1)]; + var $9914=(($9913)&65535); + var $9915=(($9909+($9914<<2))|0); + var $9916=$9915; + var $9917=$9916; + HEAPF32[(($9917)>>2)]=$9906; + __label__ = 487; break; + case 390: + var $9919=$2; + var $9920=$2; + var $9921=(($9920+64)|0); + var $9922=HEAP32[(($9921)>>2)]; + var $9923=$st; + var $9924=(($9923+2)|0); + var $9925=$9924; + var $9926=HEAP16[(($9925)>>1)]; + var $9927=(($9926)&65535); + var $9928=(($9922+($9927<<2))|0); + var $9929=$9928; + var $9930=$9929; + var $9931=HEAP32[(($9930)>>2)]; + var $9932=_prog_getstring($9919, $9931); + var $9933=$2; + var $9934=$2; + var $9935=(($9934+64)|0); + var $9936=HEAP32[(($9935)>>2)]; + var $9937=$st; + var $9938=(($9937+4)|0); + var $9939=$9938; + var $9940=HEAP16[(($9939)>>1)]; + var $9941=(($9940)&65535); + var $9942=(($9936+($9941<<2))|0); + var $9943=$9942; + var $9944=$9943; + var $9945=HEAP32[(($9944)>>2)]; + var $9946=_prog_getstring($9933, $9945); + var $9947=_strcmp($9932, $9946); + var $9948=(($9947)|0)!=0; + var $9949=$9948 ^ 1; + var $9950=(($9949)&1); + var $9951=(($9950)|0); + var $9952=$2; + var $9953=(($9952+64)|0); + var $9954=HEAP32[(($9953)>>2)]; + var $9955=$st; + var $9956=(($9955+6)|0); + var $9957=$9956; + var $9958=HEAP16[(($9957)>>1)]; + var $9959=(($9958)&65535); + var $9960=(($9954+($9959<<2))|0); + var $9961=$9960; + var $9962=$9961; + HEAPF32[(($9962)>>2)]=$9951; + __label__ = 487; break; + case 391: + var $9964=$2; + var $9965=(($9964+64)|0); + var $9966=HEAP32[(($9965)>>2)]; + var $9967=$st; + var $9968=(($9967+2)|0); + var $9969=$9968; + var $9970=HEAP16[(($9969)>>1)]; + var $9971=(($9970)&65535); + var $9972=(($9966+($9971<<2))|0); + var $9973=$9972; + var $9974=$9973; + var $9975=HEAP32[(($9974)>>2)]; + var $9976=$2; + var $9977=(($9976+64)|0); + var $9978=HEAP32[(($9977)>>2)]; + var $9979=$st; + var $9980=(($9979+4)|0); + var $9981=$9980; + var $9982=HEAP16[(($9981)>>1)]; + var $9983=(($9982)&65535); + var $9984=(($9978+($9983<<2))|0); + var $9985=$9984; + var $9986=$9985; + var $9987=HEAP32[(($9986)>>2)]; + var $9988=(($9975)|0)==(($9987)|0); + var $9989=(($9988)&1); + var $9990=(($9989)|0); + var $9991=$2; + var $9992=(($9991+64)|0); + var $9993=HEAP32[(($9992)>>2)]; + var $9994=$st; + var $9995=(($9994+6)|0); + var $9996=$9995; + var $9997=HEAP16[(($9996)>>1)]; + var $9998=(($9997)&65535); + var $9999=(($9993+($9998<<2))|0); + var $10000=$9999; + var $10001=$10000; + HEAPF32[(($10001)>>2)]=$9990; + __label__ = 487; break; + case 392: + var $10003=$2; + var $10004=(($10003+64)|0); + var $10005=HEAP32[(($10004)>>2)]; + var $10006=$st; + var $10007=(($10006+2)|0); + var $10008=$10007; + var $10009=HEAP16[(($10008)>>1)]; + var $10010=(($10009)&65535); + var $10011=(($10005+($10010<<2))|0); + var $10012=$10011; + var $10013=$10012; + var $10014=HEAP32[(($10013)>>2)]; + var $10015=$2; + var $10016=(($10015+64)|0); + var $10017=HEAP32[(($10016)>>2)]; + var $10018=$st; + var $10019=(($10018+4)|0); + var $10020=$10019; + var $10021=HEAP16[(($10020)>>1)]; + var $10022=(($10021)&65535); + var $10023=(($10017+($10022<<2))|0); + var $10024=$10023; + var $10025=$10024; + var $10026=HEAP32[(($10025)>>2)]; + var $10027=(($10014)|0)==(($10026)|0); + var $10028=(($10027)&1); + var $10029=(($10028)|0); + var $10030=$2; + var $10031=(($10030+64)|0); + var $10032=HEAP32[(($10031)>>2)]; + var $10033=$st; + var $10034=(($10033+6)|0); + var $10035=$10034; + var $10036=HEAP16[(($10035)>>1)]; + var $10037=(($10036)&65535); + var $10038=(($10032+($10037<<2))|0); + var $10039=$10038; + var $10040=$10039; + HEAPF32[(($10040)>>2)]=$10029; + __label__ = 487; break; + case 393: + var $10042=$2; + var $10043=(($10042+64)|0); + var $10044=HEAP32[(($10043)>>2)]; + var $10045=$st; + var $10046=(($10045+2)|0); + var $10047=$10046; + var $10048=HEAP16[(($10047)>>1)]; + var $10049=(($10048)&65535); + var $10050=(($10044+($10049<<2))|0); + var $10051=$10050; + var $10052=$10051; + var $10053=HEAPF32[(($10052)>>2)]; + var $10054=$2; + var $10055=(($10054+64)|0); + var $10056=HEAP32[(($10055)>>2)]; + var $10057=$st; + var $10058=(($10057+4)|0); + var $10059=$10058; + var $10060=HEAP16[(($10059)>>1)]; + var $10061=(($10060)&65535); + var $10062=(($10056+($10061<<2))|0); + var $10063=$10062; + var $10064=$10063; + var $10065=HEAPF32[(($10064)>>2)]; + var $10066=$10053 != $10065; + var $10067=(($10066)&1); + var $10068=(($10067)|0); + var $10069=$2; + var $10070=(($10069+64)|0); + var $10071=HEAP32[(($10070)>>2)]; + var $10072=$st; + var $10073=(($10072+6)|0); + var $10074=$10073; + var $10075=HEAP16[(($10074)>>1)]; + var $10076=(($10075)&65535); + var $10077=(($10071+($10076<<2))|0); + var $10078=$10077; + var $10079=$10078; + HEAPF32[(($10079)>>2)]=$10068; + __label__ = 487; break; + case 394: + var $10081=$2; + var $10082=(($10081+64)|0); + var $10083=HEAP32[(($10082)>>2)]; + var $10084=$st; + var $10085=(($10084+2)|0); + var $10086=$10085; + var $10087=HEAP16[(($10086)>>1)]; + var $10088=(($10087)&65535); + var $10089=(($10083+($10088<<2))|0); + var $10090=$10089; + var $10091=$10090; + var $10092=(($10091)|0); + var $10093=HEAPF32[(($10092)>>2)]; + var $10094=$2; + var $10095=(($10094+64)|0); + var $10096=HEAP32[(($10095)>>2)]; + var $10097=$st; + var $10098=(($10097+4)|0); + var $10099=$10098; + var $10100=HEAP16[(($10099)>>1)]; + var $10101=(($10100)&65535); + var $10102=(($10096+($10101<<2))|0); + var $10103=$10102; + var $10104=$10103; + var $10105=(($10104)|0); + var $10106=HEAPF32[(($10105)>>2)]; + var $10107=$10093 != $10106; + if ($10107) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 395; break; } + case 395: + var $10109=$2; + var $10110=(($10109+64)|0); + var $10111=HEAP32[(($10110)>>2)]; + var $10112=$st; + var $10113=(($10112+2)|0); + var $10114=$10113; + var $10115=HEAP16[(($10114)>>1)]; + var $10116=(($10115)&65535); + var $10117=(($10111+($10116<<2))|0); + var $10118=$10117; + var $10119=$10118; + var $10120=(($10119+4)|0); + var $10121=HEAPF32[(($10120)>>2)]; + var $10122=$2; + var $10123=(($10122+64)|0); + var $10124=HEAP32[(($10123)>>2)]; + var $10125=$st; + var $10126=(($10125+4)|0); + var $10127=$10126; + var $10128=HEAP16[(($10127)>>1)]; + var $10129=(($10128)&65535); + var $10130=(($10124+($10129<<2))|0); + var $10131=$10130; + var $10132=$10131; + var $10133=(($10132+4)|0); + var $10134=HEAPF32[(($10133)>>2)]; + var $10135=$10121 != $10134; + if ($10135) { var $10165 = 1;__label__ = 397; break; } else { __label__ = 396; break; } + case 396: + var $10137=$2; + var $10138=(($10137+64)|0); + var $10139=HEAP32[(($10138)>>2)]; + var $10140=$st; + var $10141=(($10140+2)|0); + var $10142=$10141; + var $10143=HEAP16[(($10142)>>1)]; + var $10144=(($10143)&65535); + var $10145=(($10139+($10144<<2))|0); + var $10146=$10145; + var $10147=$10146; + var $10148=(($10147+8)|0); + var $10149=HEAPF32[(($10148)>>2)]; + var $10150=$2; + var $10151=(($10150+64)|0); + var $10152=HEAP32[(($10151)>>2)]; + var $10153=$st; + var $10154=(($10153+4)|0); + var $10155=$10154; + var $10156=HEAP16[(($10155)>>1)]; + var $10157=(($10156)&65535); + var $10158=(($10152+($10157<<2))|0); + var $10159=$10158; + var $10160=$10159; + var $10161=(($10160+8)|0); + var $10162=HEAPF32[(($10161)>>2)]; + var $10163=$10149 != $10162; + var $10165 = $10163;__label__ = 397; break; + case 397: + var $10165; + var $10166=(($10165)&1); + var $10167=(($10166)|0); + var $10168=$2; + var $10169=(($10168+64)|0); + var $10170=HEAP32[(($10169)>>2)]; + var $10171=$st; + var $10172=(($10171+6)|0); + var $10173=$10172; + var $10174=HEAP16[(($10173)>>1)]; + var $10175=(($10174)&65535); + var $10176=(($10170+($10175<<2))|0); + var $10177=$10176; + var $10178=$10177; + HEAPF32[(($10178)>>2)]=$10167; + __label__ = 487; break; + case 398: + var $10180=$2; + var $10181=$2; + var $10182=(($10181+64)|0); + var $10183=HEAP32[(($10182)>>2)]; + var $10184=$st; + var $10185=(($10184+2)|0); + var $10186=$10185; + var $10187=HEAP16[(($10186)>>1)]; + var $10188=(($10187)&65535); + var $10189=(($10183+($10188<<2))|0); + var $10190=$10189; + var $10191=$10190; + var $10192=HEAP32[(($10191)>>2)]; + var $10193=_prog_getstring($10180, $10192); + var $10194=$2; + var $10195=$2; + var $10196=(($10195+64)|0); + var $10197=HEAP32[(($10196)>>2)]; + var $10198=$st; + var $10199=(($10198+4)|0); + var $10200=$10199; + var $10201=HEAP16[(($10200)>>1)]; + var $10202=(($10201)&65535); + var $10203=(($10197+($10202<<2))|0); + var $10204=$10203; + var $10205=$10204; + var $10206=HEAP32[(($10205)>>2)]; + var $10207=_prog_getstring($10194, $10206); + var $10208=_strcmp($10193, $10207); + var $10209=(($10208)|0)!=0; + var $10210=$10209 ^ 1; + var $10211=$10210 ^ 1; + var $10212=(($10211)&1); + var $10213=(($10212)|0); + var $10214=$2; + var $10215=(($10214+64)|0); + var $10216=HEAP32[(($10215)>>2)]; + var $10217=$st; + var $10218=(($10217+6)|0); + var $10219=$10218; + var $10220=HEAP16[(($10219)>>1)]; + var $10221=(($10220)&65535); + var $10222=(($10216+($10221<<2))|0); + var $10223=$10222; + var $10224=$10223; + HEAPF32[(($10224)>>2)]=$10213; + __label__ = 487; break; + case 399: + var $10226=$2; + var $10227=(($10226+64)|0); + var $10228=HEAP32[(($10227)>>2)]; + var $10229=$st; + var $10230=(($10229+2)|0); + var $10231=$10230; + var $10232=HEAP16[(($10231)>>1)]; + var $10233=(($10232)&65535); + var $10234=(($10228+($10233<<2))|0); + var $10235=$10234; + var $10236=$10235; + var $10237=HEAP32[(($10236)>>2)]; + var $10238=$2; + var $10239=(($10238+64)|0); + var $10240=HEAP32[(($10239)>>2)]; + var $10241=$st; + var $10242=(($10241+4)|0); + var $10243=$10242; + var $10244=HEAP16[(($10243)>>1)]; + var $10245=(($10244)&65535); + var $10246=(($10240+($10245<<2))|0); + var $10247=$10246; + var $10248=$10247; + var $10249=HEAP32[(($10248)>>2)]; + var $10250=(($10237)|0)!=(($10249)|0); + var $10251=(($10250)&1); + var $10252=(($10251)|0); + var $10253=$2; + var $10254=(($10253+64)|0); + var $10255=HEAP32[(($10254)>>2)]; + var $10256=$st; + var $10257=(($10256+6)|0); + var $10258=$10257; + var $10259=HEAP16[(($10258)>>1)]; + var $10260=(($10259)&65535); + var $10261=(($10255+($10260<<2))|0); + var $10262=$10261; + var $10263=$10262; + HEAPF32[(($10263)>>2)]=$10252; + __label__ = 487; break; + case 400: + var $10265=$2; + var $10266=(($10265+64)|0); + var $10267=HEAP32[(($10266)>>2)]; + var $10268=$st; + var $10269=(($10268+2)|0); + var $10270=$10269; + var $10271=HEAP16[(($10270)>>1)]; + var $10272=(($10271)&65535); + var $10273=(($10267+($10272<<2))|0); + var $10274=$10273; + var $10275=$10274; + var $10276=HEAP32[(($10275)>>2)]; + var $10277=$2; + var $10278=(($10277+64)|0); + var $10279=HEAP32[(($10278)>>2)]; + var $10280=$st; + var $10281=(($10280+4)|0); + var $10282=$10281; + var $10283=HEAP16[(($10282)>>1)]; + var $10284=(($10283)&65535); + var $10285=(($10279+($10284<<2))|0); + var $10286=$10285; + var $10287=$10286; + var $10288=HEAP32[(($10287)>>2)]; + var $10289=(($10276)|0)!=(($10288)|0); + var $10290=(($10289)&1); + var $10291=(($10290)|0); + var $10292=$2; + var $10293=(($10292+64)|0); + var $10294=HEAP32[(($10293)>>2)]; + var $10295=$st; + var $10296=(($10295+6)|0); + var $10297=$10296; + var $10298=HEAP16[(($10297)>>1)]; + var $10299=(($10298)&65535); + var $10300=(($10294+($10299<<2))|0); + var $10301=$10300; + var $10302=$10301; + HEAPF32[(($10302)>>2)]=$10291; + __label__ = 487; break; + case 401: + var $10304=$2; + var $10305=(($10304+64)|0); + var $10306=HEAP32[(($10305)>>2)]; + var $10307=$st; + var $10308=(($10307+2)|0); + var $10309=$10308; + var $10310=HEAP16[(($10309)>>1)]; + var $10311=(($10310)&65535); + var $10312=(($10306+($10311<<2))|0); + var $10313=$10312; + var $10314=$10313; + var $10315=HEAPF32[(($10314)>>2)]; + var $10316=$2; + var $10317=(($10316+64)|0); + var $10318=HEAP32[(($10317)>>2)]; + var $10319=$st; + var $10320=(($10319+4)|0); + var $10321=$10320; + var $10322=HEAP16[(($10321)>>1)]; + var $10323=(($10322)&65535); + var $10324=(($10318+($10323<<2))|0); + var $10325=$10324; + var $10326=$10325; + var $10327=HEAPF32[(($10326)>>2)]; + var $10328=$10315 <= $10327; + var $10329=(($10328)&1); + var $10330=(($10329)|0); + var $10331=$2; + var $10332=(($10331+64)|0); + var $10333=HEAP32[(($10332)>>2)]; + var $10334=$st; + var $10335=(($10334+6)|0); + var $10336=$10335; + var $10337=HEAP16[(($10336)>>1)]; + var $10338=(($10337)&65535); + var $10339=(($10333+($10338<<2))|0); + var $10340=$10339; + var $10341=$10340; + HEAPF32[(($10341)>>2)]=$10330; + __label__ = 487; break; + case 402: + var $10343=$2; + var $10344=(($10343+64)|0); + var $10345=HEAP32[(($10344)>>2)]; + var $10346=$st; + var $10347=(($10346+2)|0); + var $10348=$10347; + var $10349=HEAP16[(($10348)>>1)]; + var $10350=(($10349)&65535); + var $10351=(($10345+($10350<<2))|0); + var $10352=$10351; + var $10353=$10352; + var $10354=HEAPF32[(($10353)>>2)]; + var $10355=$2; + var $10356=(($10355+64)|0); + var $10357=HEAP32[(($10356)>>2)]; + var $10358=$st; + var $10359=(($10358+4)|0); + var $10360=$10359; + var $10361=HEAP16[(($10360)>>1)]; + var $10362=(($10361)&65535); + var $10363=(($10357+($10362<<2))|0); + var $10364=$10363; + var $10365=$10364; + var $10366=HEAPF32[(($10365)>>2)]; + var $10367=$10354 >= $10366; + var $10368=(($10367)&1); + var $10369=(($10368)|0); + var $10370=$2; + var $10371=(($10370+64)|0); + var $10372=HEAP32[(($10371)>>2)]; + var $10373=$st; + var $10374=(($10373+6)|0); + var $10375=$10374; + var $10376=HEAP16[(($10375)>>1)]; + var $10377=(($10376)&65535); + var $10378=(($10372+($10377<<2))|0); + var $10379=$10378; + var $10380=$10379; + HEAPF32[(($10380)>>2)]=$10369; + __label__ = 487; break; + case 403: + var $10382=$2; + var $10383=(($10382+64)|0); + var $10384=HEAP32[(($10383)>>2)]; + var $10385=$st; + var $10386=(($10385+2)|0); + var $10387=$10386; + var $10388=HEAP16[(($10387)>>1)]; + var $10389=(($10388)&65535); + var $10390=(($10384+($10389<<2))|0); + var $10391=$10390; + var $10392=$10391; + var $10393=HEAPF32[(($10392)>>2)]; + var $10394=$2; + var $10395=(($10394+64)|0); + var $10396=HEAP32[(($10395)>>2)]; + var $10397=$st; + var $10398=(($10397+4)|0); + var $10399=$10398; + var $10400=HEAP16[(($10399)>>1)]; + var $10401=(($10400)&65535); + var $10402=(($10396+($10401<<2))|0); + var $10403=$10402; + var $10404=$10403; + var $10405=HEAPF32[(($10404)>>2)]; + var $10406=$10393 < $10405; + var $10407=(($10406)&1); + var $10408=(($10407)|0); + var $10409=$2; + var $10410=(($10409+64)|0); + var $10411=HEAP32[(($10410)>>2)]; + var $10412=$st; + var $10413=(($10412+6)|0); + var $10414=$10413; + var $10415=HEAP16[(($10414)>>1)]; + var $10416=(($10415)&65535); + var $10417=(($10411+($10416<<2))|0); + var $10418=$10417; + var $10419=$10418; + HEAPF32[(($10419)>>2)]=$10408; + __label__ = 487; break; + case 404: + var $10421=$2; + var $10422=(($10421+64)|0); + var $10423=HEAP32[(($10422)>>2)]; + var $10424=$st; + var $10425=(($10424+2)|0); + var $10426=$10425; + var $10427=HEAP16[(($10426)>>1)]; + var $10428=(($10427)&65535); + var $10429=(($10423+($10428<<2))|0); + var $10430=$10429; + var $10431=$10430; + var $10432=HEAPF32[(($10431)>>2)]; + var $10433=$2; + var $10434=(($10433+64)|0); + var $10435=HEAP32[(($10434)>>2)]; + var $10436=$st; + var $10437=(($10436+4)|0); + var $10438=$10437; + var $10439=HEAP16[(($10438)>>1)]; + var $10440=(($10439)&65535); + var $10441=(($10435+($10440<<2))|0); + var $10442=$10441; + var $10443=$10442; + var $10444=HEAPF32[(($10443)>>2)]; + var $10445=$10432 > $10444; + var $10446=(($10445)&1); + var $10447=(($10446)|0); + var $10448=$2; + var $10449=(($10448+64)|0); + var $10450=HEAP32[(($10449)>>2)]; + var $10451=$st; + var $10452=(($10451+6)|0); + var $10453=$10452; + var $10454=HEAP16[(($10453)>>1)]; + var $10455=(($10454)&65535); + var $10456=(($10450+($10455<<2))|0); + var $10457=$10456; + var $10458=$10457; + HEAPF32[(($10458)>>2)]=$10447; + __label__ = 487; break; + case 405: + var $10460=$2; + var $10461=(($10460+64)|0); + var $10462=HEAP32[(($10461)>>2)]; + var $10463=$st; + var $10464=(($10463+2)|0); + var $10465=$10464; + var $10466=HEAP16[(($10465)>>1)]; + var $10467=(($10466)&65535); + var $10468=(($10462+($10467<<2))|0); + var $10469=$10468; + var $10470=$10469; + var $10471=HEAP32[(($10470)>>2)]; + var $10472=(($10471)|0) < 0; + if ($10472) { __label__ = 407; break; } else { __label__ = 406; break; } + case 406: + var $10474=$2; + var $10475=(($10474+64)|0); + var $10476=HEAP32[(($10475)>>2)]; + var $10477=$st; + var $10478=(($10477+2)|0); + var $10479=$10478; + var $10480=HEAP16[(($10479)>>1)]; + var $10481=(($10480)&65535); + var $10482=(($10476+($10481<<2))|0); + var $10483=$10482; + var $10484=$10483; + var $10485=HEAP32[(($10484)>>2)]; + var $10486=$2; + var $10487=(($10486+140)|0); + var $10488=HEAP32[(($10487)>>2)]; + var $10489=(($10485)|0) >= (($10488)|0); + if ($10489) { __label__ = 407; break; } else { __label__ = 408; break; } + case 407: + var $10491=$2; + var $10492=$2; + var $10493=(($10492)|0); + var $10494=HEAP32[(($10493)>>2)]; + _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)); + __label__ = 488; break; + case 408: + var $10496=$2; + var $10497=(($10496+64)|0); + var $10498=HEAP32[(($10497)>>2)]; + var $10499=$st; + var $10500=(($10499+4)|0); + var $10501=$10500; + var $10502=HEAP16[(($10501)>>1)]; + var $10503=(($10502)&65535); + var $10504=(($10498+($10503<<2))|0); + var $10505=$10504; + var $10506=$10505; + var $10507=HEAP32[(($10506)>>2)]; + var $10508=$2; + var $10509=(($10508+144)|0); + var $10510=HEAP32[(($10509)>>2)]; + var $10511=(($10507)>>>0) >= (($10510)>>>0); + if ($10511) { __label__ = 409; break; } else { __label__ = 410; break; } + case 409: + var $10513=$2; + var $10514=$2; + var $10515=(($10514)|0); + var $10516=HEAP32[(($10515)>>2)]; + var $10517=$2; + var $10518=(($10517+64)|0); + var $10519=HEAP32[(($10518)>>2)]; + var $10520=$st; + var $10521=(($10520+4)|0); + var $10522=$10521; + var $10523=HEAP16[(($10522)>>1)]; + var $10524=(($10523)&65535); + var $10525=(($10519+($10524<<2))|0); + var $10526=$10525; + var $10527=$10526; + var $10528=HEAP32[(($10527)>>2)]; + _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)); + __label__ = 488; break; + case 410: + var $10530=$2; + var $10531=$2; + var $10532=(($10531+64)|0); + var $10533=HEAP32[(($10532)>>2)]; + var $10534=$st; + var $10535=(($10534+2)|0); + var $10536=$10535; + var $10537=HEAP16[(($10536)>>1)]; + var $10538=(($10537)&65535); + var $10539=(($10533+($10538<<2))|0); + var $10540=$10539; + var $10541=$10540; + var $10542=HEAP32[(($10541)>>2)]; + var $10543=_prog_getedict($10530, $10542); + $ed10=$10543; + var $10544=$ed10; + var $10545=$10544; + var $10546=$2; + var $10547=(($10546+64)|0); + var $10548=HEAP32[(($10547)>>2)]; + var $10549=$st; + var $10550=(($10549+4)|0); + var $10551=$10550; + var $10552=HEAP16[(($10551)>>1)]; + var $10553=(($10552)&65535); + var $10554=(($10548+($10553<<2))|0); + var $10555=$10554; + var $10556=$10555; + var $10557=HEAP32[(($10556)>>2)]; + var $10558=(($10545+($10557<<2))|0); + var $10559=$10558; + var $10560=$10559; + var $10561=HEAP32[(($10560)>>2)]; + var $10562=$2; + var $10563=(($10562+64)|0); + var $10564=HEAP32[(($10563)>>2)]; + var $10565=$st; + var $10566=(($10565+6)|0); + var $10567=$10566; + var $10568=HEAP16[(($10567)>>1)]; + var $10569=(($10568)&65535); + var $10570=(($10564+($10569<<2))|0); + var $10571=$10570; + var $10572=$10571; + HEAP32[(($10572)>>2)]=$10561; + __label__ = 487; break; + case 411: + var $10574=$2; + var $10575=(($10574+64)|0); + var $10576=HEAP32[(($10575)>>2)]; + var $10577=$st; + var $10578=(($10577+2)|0); + var $10579=$10578; + var $10580=HEAP16[(($10579)>>1)]; + var $10581=(($10580)&65535); + var $10582=(($10576+($10581<<2))|0); + var $10583=$10582; + var $10584=$10583; + var $10585=HEAP32[(($10584)>>2)]; + var $10586=(($10585)|0) < 0; + if ($10586) { __label__ = 413; break; } else { __label__ = 412; break; } + case 412: + var $10588=$2; + var $10589=(($10588+64)|0); + var $10590=HEAP32[(($10589)>>2)]; + var $10591=$st; + var $10592=(($10591+2)|0); + var $10593=$10592; + var $10594=HEAP16[(($10593)>>1)]; + var $10595=(($10594)&65535); + var $10596=(($10590+($10595<<2))|0); + var $10597=$10596; + var $10598=$10597; + var $10599=HEAP32[(($10598)>>2)]; + var $10600=$2; + var $10601=(($10600+140)|0); + var $10602=HEAP32[(($10601)>>2)]; + var $10603=(($10599)|0) >= (($10602)|0); + if ($10603) { __label__ = 413; break; } else { __label__ = 414; break; } + case 413: + var $10605=$2; + var $10606=$2; + var $10607=(($10606)|0); + var $10608=HEAP32[(($10607)>>2)]; + _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)); + __label__ = 488; break; + case 414: + var $10610=$2; + var $10611=(($10610+64)|0); + var $10612=HEAP32[(($10611)>>2)]; + var $10613=$st; + var $10614=(($10613+4)|0); + var $10615=$10614; + var $10616=HEAP16[(($10615)>>1)]; + var $10617=(($10616)&65535); + var $10618=(($10612+($10617<<2))|0); + var $10619=$10618; + var $10620=$10619; + var $10621=HEAP32[(($10620)>>2)]; + var $10622=(($10621)|0) < 0; + if ($10622) { __label__ = 416; break; } else { __label__ = 415; break; } + case 415: + var $10624=$2; + var $10625=(($10624+64)|0); + var $10626=HEAP32[(($10625)>>2)]; + var $10627=$st; + var $10628=(($10627+4)|0); + var $10629=$10628; + var $10630=HEAP16[(($10629)>>1)]; + var $10631=(($10630)&65535); + var $10632=(($10626+($10631<<2))|0); + var $10633=$10632; + var $10634=$10633; + var $10635=HEAP32[(($10634)>>2)]; + var $10636=((($10635)+(3))|0); + var $10637=$2; + var $10638=(($10637+144)|0); + var $10639=HEAP32[(($10638)>>2)]; + var $10640=(($10636)>>>0) > (($10639)>>>0); + if ($10640) { __label__ = 416; break; } else { __label__ = 417; break; } + case 416: + var $10642=$2; + var $10643=$2; + var $10644=(($10643)|0); + var $10645=HEAP32[(($10644)>>2)]; + var $10646=$2; + var $10647=(($10646+64)|0); + var $10648=HEAP32[(($10647)>>2)]; + var $10649=$st; + var $10650=(($10649+4)|0); + var $10651=$10650; + var $10652=HEAP16[(($10651)>>1)]; + var $10653=(($10652)&65535); + var $10654=(($10648+($10653<<2))|0); + var $10655=$10654; + var $10656=$10655; + var $10657=HEAP32[(($10656)>>2)]; + var $10658=((($10657)+(2))|0); + _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)); + __label__ = 488; break; + case 417: + var $10660=$2; + var $10661=$2; + var $10662=(($10661+64)|0); + var $10663=HEAP32[(($10662)>>2)]; + var $10664=$st; + var $10665=(($10664+2)|0); + var $10666=$10665; + var $10667=HEAP16[(($10666)>>1)]; + var $10668=(($10667)&65535); + var $10669=(($10663+($10668<<2))|0); + var $10670=$10669; + var $10671=$10670; + var $10672=HEAP32[(($10671)>>2)]; + var $10673=_prog_getedict($10660, $10672); + $ed10=$10673; + var $10674=$ed10; + var $10675=$10674; + var $10676=$2; + var $10677=(($10676+64)|0); + var $10678=HEAP32[(($10677)>>2)]; + var $10679=$st; + var $10680=(($10679+4)|0); + var $10681=$10680; + var $10682=HEAP16[(($10681)>>1)]; + var $10683=(($10682)&65535); + var $10684=(($10678+($10683<<2))|0); + var $10685=$10684; + var $10686=$10685; + var $10687=HEAP32[(($10686)>>2)]; + var $10688=(($10675+($10687<<2))|0); + var $10689=$10688; + var $10690=$10689; + var $10691=(($10690)|0); + var $10692=HEAP32[(($10691)>>2)]; + var $10693=$2; + var $10694=(($10693+64)|0); + var $10695=HEAP32[(($10694)>>2)]; + var $10696=$st; + var $10697=(($10696+6)|0); + var $10698=$10697; + var $10699=HEAP16[(($10698)>>1)]; + var $10700=(($10699)&65535); + var $10701=(($10695+($10700<<2))|0); + var $10702=$10701; + var $10703=$10702; + var $10704=(($10703)|0); + HEAP32[(($10704)>>2)]=$10692; + var $10705=$ed10; + var $10706=$10705; + var $10707=$2; + var $10708=(($10707+64)|0); + var $10709=HEAP32[(($10708)>>2)]; + var $10710=$st; + var $10711=(($10710+4)|0); + var $10712=$10711; + var $10713=HEAP16[(($10712)>>1)]; + var $10714=(($10713)&65535); + var $10715=(($10709+($10714<<2))|0); + var $10716=$10715; + var $10717=$10716; + var $10718=HEAP32[(($10717)>>2)]; + var $10719=(($10706+($10718<<2))|0); + var $10720=$10719; + var $10721=$10720; + var $10722=(($10721+4)|0); + var $10723=HEAP32[(($10722)>>2)]; + var $10724=$2; + var $10725=(($10724+64)|0); + var $10726=HEAP32[(($10725)>>2)]; + var $10727=$st; + var $10728=(($10727+6)|0); + var $10729=$10728; + var $10730=HEAP16[(($10729)>>1)]; + var $10731=(($10730)&65535); + var $10732=(($10726+($10731<<2))|0); + var $10733=$10732; + var $10734=$10733; + var $10735=(($10734+4)|0); + HEAP32[(($10735)>>2)]=$10723; + var $10736=$ed10; + var $10737=$10736; + var $10738=$2; + var $10739=(($10738+64)|0); + var $10740=HEAP32[(($10739)>>2)]; + var $10741=$st; + var $10742=(($10741+4)|0); + var $10743=$10742; + var $10744=HEAP16[(($10743)>>1)]; + var $10745=(($10744)&65535); + var $10746=(($10740+($10745<<2))|0); + var $10747=$10746; + var $10748=$10747; + var $10749=HEAP32[(($10748)>>2)]; + var $10750=(($10737+($10749<<2))|0); + var $10751=$10750; + var $10752=$10751; + var $10753=(($10752+8)|0); + var $10754=HEAP32[(($10753)>>2)]; + var $10755=$2; + var $10756=(($10755+64)|0); + var $10757=HEAP32[(($10756)>>2)]; + var $10758=$st; + var $10759=(($10758+6)|0); + var $10760=$10759; + var $10761=HEAP16[(($10760)>>1)]; + var $10762=(($10761)&65535); + var $10763=(($10757+($10762<<2))|0); + var $10764=$10763; + var $10765=$10764; + var $10766=(($10765+8)|0); + HEAP32[(($10766)>>2)]=$10754; + __label__ = 487; break; + case 418: + var $10768=$2; + var $10769=(($10768+64)|0); + var $10770=HEAP32[(($10769)>>2)]; + var $10771=$st; + var $10772=(($10771+2)|0); + var $10773=$10772; + var $10774=HEAP16[(($10773)>>1)]; + var $10775=(($10774)&65535); + var $10776=(($10770+($10775<<2))|0); + var $10777=$10776; + var $10778=$10777; + var $10779=HEAP32[(($10778)>>2)]; + var $10780=(($10779)|0) < 0; + if ($10780) { __label__ = 420; break; } else { __label__ = 419; break; } + case 419: + var $10782=$2; + var $10783=(($10782+64)|0); + var $10784=HEAP32[(($10783)>>2)]; + var $10785=$st; + var $10786=(($10785+2)|0); + var $10787=$10786; + var $10788=HEAP16[(($10787)>>1)]; + var $10789=(($10788)&65535); + var $10790=(($10784+($10789<<2))|0); + var $10791=$10790; + var $10792=$10791; + var $10793=HEAP32[(($10792)>>2)]; + var $10794=$2; + var $10795=(($10794+140)|0); + var $10796=HEAP32[(($10795)>>2)]; + var $10797=(($10793)|0) >= (($10796)|0); + if ($10797) { __label__ = 420; break; } else { __label__ = 421; break; } + case 420: + var $10799=$2; + var $10800=$2; + var $10801=(($10800)|0); + var $10802=HEAP32[(($10801)>>2)]; + var $10803=$2; + var $10804=(($10803+64)|0); + var $10805=HEAP32[(($10804)>>2)]; + var $10806=$st; + var $10807=(($10806+2)|0); + var $10808=$10807; + var $10809=HEAP16[(($10808)>>1)]; + var $10810=(($10809)&65535); + var $10811=(($10805+($10810<<2))|0); + var $10812=$10811; + var $10813=$10812; + var $10814=HEAP32[(($10813)>>2)]; + _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)); + __label__ = 488; break; + case 421: + var $10816=$2; + var $10817=(($10816+64)|0); + var $10818=HEAP32[(($10817)>>2)]; + var $10819=$st; + var $10820=(($10819+4)|0); + var $10821=$10820; + var $10822=HEAP16[(($10821)>>1)]; + var $10823=(($10822)&65535); + var $10824=(($10818+($10823<<2))|0); + var $10825=$10824; + var $10826=$10825; + var $10827=HEAP32[(($10826)>>2)]; + var $10828=$2; + var $10829=(($10828+144)|0); + var $10830=HEAP32[(($10829)>>2)]; + var $10831=(($10827)>>>0) >= (($10830)>>>0); + if ($10831) { __label__ = 422; break; } else { __label__ = 423; break; } + case 422: + var $10833=$2; + var $10834=$2; + var $10835=(($10834)|0); + var $10836=HEAP32[(($10835)>>2)]; + var $10837=$2; + var $10838=(($10837+64)|0); + var $10839=HEAP32[(($10838)>>2)]; + var $10840=$st; + var $10841=(($10840+4)|0); + var $10842=$10841; + var $10843=HEAP16[(($10842)>>1)]; + var $10844=(($10843)&65535); + var $10845=(($10839+($10844<<2))|0); + var $10846=$10845; + var $10847=$10846; + var $10848=HEAP32[(($10847)>>2)]; + _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)); + __label__ = 488; break; + case 423: + var $10850=$2; + var $10851=$2; + var $10852=(($10851+64)|0); + var $10853=HEAP32[(($10852)>>2)]; + var $10854=$st; + var $10855=(($10854+2)|0); + var $10856=$10855; + var $10857=HEAP16[(($10856)>>1)]; + var $10858=(($10857)&65535); + var $10859=(($10853+($10858<<2))|0); + var $10860=$10859; + var $10861=$10860; + var $10862=HEAP32[(($10861)>>2)]; + var $10863=_prog_getedict($10850, $10862); + $ed10=$10863; + var $10864=$ed10; + var $10865=$10864; + var $10866=$2; + var $10867=(($10866+76)|0); + var $10868=HEAP32[(($10867)>>2)]; + var $10869=$10865; + var $10870=$10868; + var $10871=((($10869)-($10870))|0); + var $10872=((((($10871)|0))/(4))&-1); + var $10873=$2; + var $10874=(($10873+64)|0); + var $10875=HEAP32[(($10874)>>2)]; + var $10876=$st; + var $10877=(($10876+6)|0); + var $10878=$10877; + var $10879=HEAP16[(($10878)>>1)]; + var $10880=(($10879)&65535); + var $10881=(($10875+($10880<<2))|0); + var $10882=$10881; + var $10883=$10882; + HEAP32[(($10883)>>2)]=$10872; + var $10884=$2; + var $10885=(($10884+64)|0); + var $10886=HEAP32[(($10885)>>2)]; + var $10887=$st; + var $10888=(($10887+4)|0); + var $10889=$10888; + var $10890=HEAP16[(($10889)>>1)]; + var $10891=(($10890)&65535); + var $10892=(($10886+($10891<<2))|0); + var $10893=$10892; + var $10894=$10893; + var $10895=HEAP32[(($10894)>>2)]; + var $10896=$2; + var $10897=(($10896+64)|0); + var $10898=HEAP32[(($10897)>>2)]; + var $10899=$st; + var $10900=(($10899+6)|0); + var $10901=$10900; + var $10902=HEAP16[(($10901)>>1)]; + var $10903=(($10902)&65535); + var $10904=(($10898+($10903<<2))|0); + var $10905=$10904; + var $10906=$10905; + var $10907=HEAP32[(($10906)>>2)]; + var $10908=((($10907)+($10895))|0); + HEAP32[(($10906)>>2)]=$10908; + __label__ = 487; break; + case 424: + var $10910=$2; + var $10911=(($10910+64)|0); + var $10912=HEAP32[(($10911)>>2)]; + var $10913=$st; + var $10914=(($10913+2)|0); + var $10915=$10914; + var $10916=HEAP16[(($10915)>>1)]; + var $10917=(($10916)&65535); + var $10918=(($10912+($10917<<2))|0); + var $10919=$10918; + var $10920=$10919; + var $10921=HEAP32[(($10920)>>2)]; + var $10922=$2; + var $10923=(($10922+64)|0); + var $10924=HEAP32[(($10923)>>2)]; + var $10925=$st; + var $10926=(($10925+4)|0); + var $10927=$10926; + var $10928=HEAP16[(($10927)>>1)]; + var $10929=(($10928)&65535); + var $10930=(($10924+($10929<<2))|0); + var $10931=$10930; + var $10932=$10931; + HEAP32[(($10932)>>2)]=$10921; + __label__ = 487; break; + case 425: + var $10934=$2; + var $10935=(($10934+64)|0); + var $10936=HEAP32[(($10935)>>2)]; + var $10937=$st; + var $10938=(($10937+2)|0); + var $10939=$10938; + var $10940=HEAP16[(($10939)>>1)]; + var $10941=(($10940)&65535); + var $10942=(($10936+($10941<<2))|0); + var $10943=$10942; + var $10944=$10943; + var $10945=(($10944)|0); + var $10946=HEAP32[(($10945)>>2)]; + var $10947=$2; + var $10948=(($10947+64)|0); + var $10949=HEAP32[(($10948)>>2)]; + var $10950=$st; + var $10951=(($10950+4)|0); + var $10952=$10951; + var $10953=HEAP16[(($10952)>>1)]; + var $10954=(($10953)&65535); + var $10955=(($10949+($10954<<2))|0); + var $10956=$10955; + var $10957=$10956; + var $10958=(($10957)|0); + HEAP32[(($10958)>>2)]=$10946; + var $10959=$2; + var $10960=(($10959+64)|0); + var $10961=HEAP32[(($10960)>>2)]; + var $10962=$st; + var $10963=(($10962+2)|0); + var $10964=$10963; + var $10965=HEAP16[(($10964)>>1)]; + var $10966=(($10965)&65535); + var $10967=(($10961+($10966<<2))|0); + var $10968=$10967; + var $10969=$10968; + var $10970=(($10969+4)|0); + var $10971=HEAP32[(($10970)>>2)]; + var $10972=$2; + var $10973=(($10972+64)|0); + var $10974=HEAP32[(($10973)>>2)]; + var $10975=$st; + var $10976=(($10975+4)|0); + var $10977=$10976; + var $10978=HEAP16[(($10977)>>1)]; + var $10979=(($10978)&65535); + var $10980=(($10974+($10979<<2))|0); + var $10981=$10980; + var $10982=$10981; + var $10983=(($10982+4)|0); + HEAP32[(($10983)>>2)]=$10971; + var $10984=$2; + var $10985=(($10984+64)|0); + var $10986=HEAP32[(($10985)>>2)]; + var $10987=$st; + var $10988=(($10987+2)|0); + var $10989=$10988; + var $10990=HEAP16[(($10989)>>1)]; + var $10991=(($10990)&65535); + var $10992=(($10986+($10991<<2))|0); + var $10993=$10992; + var $10994=$10993; + var $10995=(($10994+8)|0); + var $10996=HEAP32[(($10995)>>2)]; + var $10997=$2; + var $10998=(($10997+64)|0); + var $10999=HEAP32[(($10998)>>2)]; + var $11000=$st; + var $11001=(($11000+4)|0); + var $11002=$11001; + var $11003=HEAP16[(($11002)>>1)]; + var $11004=(($11003)&65535); + var $11005=(($10999+($11004<<2))|0); + var $11006=$11005; + var $11007=$11006; + var $11008=(($11007+8)|0); + HEAP32[(($11008)>>2)]=$10996; + __label__ = 487; break; + case 426: + var $11010=$2; + var $11011=(($11010+64)|0); + var $11012=HEAP32[(($11011)>>2)]; + var $11013=$st; + var $11014=(($11013+4)|0); + var $11015=$11014; + var $11016=HEAP16[(($11015)>>1)]; + var $11017=(($11016)&65535); + var $11018=(($11012+($11017<<2))|0); + var $11019=$11018; + var $11020=$11019; + var $11021=HEAP32[(($11020)>>2)]; + var $11022=(($11021)|0) < 0; + if ($11022) { __label__ = 428; break; } else { __label__ = 427; break; } + case 427: + var $11024=$2; + var $11025=(($11024+64)|0); + var $11026=HEAP32[(($11025)>>2)]; + var $11027=$st; + var $11028=(($11027+4)|0); + var $11029=$11028; + var $11030=HEAP16[(($11029)>>1)]; + var $11031=(($11030)&65535); + var $11032=(($11026+($11031<<2))|0); + var $11033=$11032; + var $11034=$11033; + var $11035=HEAP32[(($11034)>>2)]; + var $11036=$2; + var $11037=(($11036+80)|0); + var $11038=HEAP32[(($11037)>>2)]; + var $11039=(($11035)>>>0) >= (($11038)>>>0); + if ($11039) { __label__ = 428; break; } else { __label__ = 429; break; } + case 428: + var $11041=$2; + var $11042=$2; + var $11043=(($11042)|0); + var $11044=HEAP32[(($11043)>>2)]; + var $11045=$2; + var $11046=(($11045+64)|0); + var $11047=HEAP32[(($11046)>>2)]; + var $11048=$st; + var $11049=(($11048+4)|0); + var $11050=$11049; + var $11051=HEAP16[(($11050)>>1)]; + var $11052=(($11051)&65535); + var $11053=(($11047+($11052<<2))|0); + var $11054=$11053; + var $11055=$11054; + var $11056=HEAP32[(($11055)>>2)]; + _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)); + __label__ = 488; break; + case 429: + var $11058=$2; + var $11059=(($11058+64)|0); + var $11060=HEAP32[(($11059)>>2)]; + var $11061=$st; + var $11062=(($11061+4)|0); + var $11063=$11062; + var $11064=HEAP16[(($11063)>>1)]; + var $11065=(($11064)&65535); + var $11066=(($11060+($11065<<2))|0); + var $11067=$11066; + var $11068=$11067; + var $11069=HEAP32[(($11068)>>2)]; + var $11070=$2; + var $11071=(($11070+144)|0); + var $11072=HEAP32[(($11071)>>2)]; + var $11073=(($11069)>>>0) < (($11072)>>>0); + if ($11073) { __label__ = 430; break; } else { __label__ = 432; break; } + case 430: + var $11075=$2; + var $11076=(($11075+148)|0); + var $11077=HEAP8[($11076)]; + var $11078=(($11077) & 1); + if ($11078) { __label__ = 432; break; } else { __label__ = 431; break; } + case 431: + var $11080=$2; + var $11081=$2; + var $11082=(($11081)|0); + var $11083=HEAP32[(($11082)>>2)]; + var $11084=$2; + var $11085=$2; + var $11086=$2; + var $11087=(($11086+64)|0); + var $11088=HEAP32[(($11087)>>2)]; + var $11089=$st; + var $11090=(($11089+4)|0); + var $11091=$11090; + var $11092=HEAP16[(($11091)>>1)]; + var $11093=(($11092)&65535); + var $11094=(($11088+($11093<<2))|0); + var $11095=$11094; + var $11096=$11095; + var $11097=HEAP32[(($11096)>>2)]; + var $11098=_prog_entfield($11085, $11097); + var $11099=(($11098+4)|0); + var $11100=HEAP32[(($11099)>>2)]; + var $11101=_prog_getstring($11084, $11100); + var $11102=$2; + var $11103=(($11102+64)|0); + var $11104=HEAP32[(($11103)>>2)]; + var $11105=$st; + var $11106=(($11105+4)|0); + var $11107=$11106; + var $11108=HEAP16[(($11107)>>1)]; + var $11109=(($11108)&65535); + var $11110=(($11104+($11109<<2))|0); + var $11111=$11110; + var $11112=$11111; + var $11113=HEAP32[(($11112)>>2)]; + _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)); + __label__ = 432; break; + case 432: + var $11115=$2; + var $11116=(($11115+76)|0); + var $11117=HEAP32[(($11116)>>2)]; + var $11118=$2; + var $11119=(($11118+64)|0); + var $11120=HEAP32[(($11119)>>2)]; + var $11121=$st; + var $11122=(($11121+4)|0); + var $11123=$11122; + var $11124=HEAP16[(($11123)>>1)]; + var $11125=(($11124)&65535); + var $11126=(($11120+($11125<<2))|0); + var $11127=$11126; + var $11128=$11127; + var $11129=HEAP32[(($11128)>>2)]; + var $11130=(($11117+($11129<<2))|0); + var $11131=$11130; + $ptr11=$11131; + var $11132=$2; + var $11133=(($11132+64)|0); + var $11134=HEAP32[(($11133)>>2)]; + var $11135=$st; + var $11136=(($11135+2)|0); + var $11137=$11136; + var $11138=HEAP16[(($11137)>>1)]; + var $11139=(($11138)&65535); + var $11140=(($11134+($11139<<2))|0); + var $11141=$11140; + var $11142=$11141; + var $11143=HEAP32[(($11142)>>2)]; + var $11144=$ptr11; + var $11145=$11144; + HEAP32[(($11145)>>2)]=$11143; + __label__ = 487; break; + case 433: + var $11147=$2; + var $11148=(($11147+64)|0); + var $11149=HEAP32[(($11148)>>2)]; + var $11150=$st; + var $11151=(($11150+4)|0); + var $11152=$11151; + var $11153=HEAP16[(($11152)>>1)]; + var $11154=(($11153)&65535); + var $11155=(($11149+($11154<<2))|0); + var $11156=$11155; + var $11157=$11156; + var $11158=HEAP32[(($11157)>>2)]; + var $11159=(($11158)|0) < 0; + if ($11159) { __label__ = 435; break; } else { __label__ = 434; break; } + case 434: + var $11161=$2; + var $11162=(($11161+64)|0); + var $11163=HEAP32[(($11162)>>2)]; + var $11164=$st; + var $11165=(($11164+4)|0); + var $11166=$11165; + var $11167=HEAP16[(($11166)>>1)]; + var $11168=(($11167)&65535); + var $11169=(($11163+($11168<<2))|0); + var $11170=$11169; + var $11171=$11170; + var $11172=HEAP32[(($11171)>>2)]; + var $11173=((($11172)+(2))|0); + var $11174=$2; + var $11175=(($11174+80)|0); + var $11176=HEAP32[(($11175)>>2)]; + var $11177=(($11173)>>>0) >= (($11176)>>>0); + if ($11177) { __label__ = 435; break; } else { __label__ = 436; break; } + case 435: + var $11179=$2; + var $11180=$2; + var $11181=(($11180)|0); + var $11182=HEAP32[(($11181)>>2)]; + var $11183=$2; + var $11184=(($11183+64)|0); + var $11185=HEAP32[(($11184)>>2)]; + var $11186=$st; + var $11187=(($11186+4)|0); + var $11188=$11187; + var $11189=HEAP16[(($11188)>>1)]; + var $11190=(($11189)&65535); + var $11191=(($11185+($11190<<2))|0); + var $11192=$11191; + var $11193=$11192; + var $11194=HEAP32[(($11193)>>2)]; + _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)); + __label__ = 488; break; + case 436: + var $11196=$2; + var $11197=(($11196+64)|0); + var $11198=HEAP32[(($11197)>>2)]; + var $11199=$st; + var $11200=(($11199+4)|0); + var $11201=$11200; + var $11202=HEAP16[(($11201)>>1)]; + var $11203=(($11202)&65535); + var $11204=(($11198+($11203<<2))|0); + var $11205=$11204; + var $11206=$11205; + var $11207=HEAP32[(($11206)>>2)]; + var $11208=$2; + var $11209=(($11208+144)|0); + var $11210=HEAP32[(($11209)>>2)]; + var $11211=(($11207)>>>0) < (($11210)>>>0); + if ($11211) { __label__ = 437; break; } else { __label__ = 439; break; } + case 437: + var $11213=$2; + var $11214=(($11213+148)|0); + var $11215=HEAP8[($11214)]; + var $11216=(($11215) & 1); + if ($11216) { __label__ = 439; break; } else { __label__ = 438; break; } + case 438: + var $11218=$2; + var $11219=$2; + var $11220=(($11219)|0); + var $11221=HEAP32[(($11220)>>2)]; + var $11222=$2; + var $11223=$2; + var $11224=$2; + var $11225=(($11224+64)|0); + var $11226=HEAP32[(($11225)>>2)]; + var $11227=$st; + var $11228=(($11227+4)|0); + var $11229=$11228; + var $11230=HEAP16[(($11229)>>1)]; + var $11231=(($11230)&65535); + var $11232=(($11226+($11231<<2))|0); + var $11233=$11232; + var $11234=$11233; + var $11235=HEAP32[(($11234)>>2)]; + var $11236=_prog_entfield($11223, $11235); + var $11237=(($11236+4)|0); + var $11238=HEAP32[(($11237)>>2)]; + var $11239=_prog_getstring($11222, $11238); + var $11240=$2; + var $11241=(($11240+64)|0); + var $11242=HEAP32[(($11241)>>2)]; + var $11243=$st; + var $11244=(($11243+4)|0); + var $11245=$11244; + var $11246=HEAP16[(($11245)>>1)]; + var $11247=(($11246)&65535); + var $11248=(($11242+($11247<<2))|0); + var $11249=$11248; + var $11250=$11249; + var $11251=HEAP32[(($11250)>>2)]; + _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)); + __label__ = 439; break; + case 439: + var $11253=$2; + var $11254=(($11253+76)|0); + var $11255=HEAP32[(($11254)>>2)]; + var $11256=$2; + var $11257=(($11256+64)|0); + var $11258=HEAP32[(($11257)>>2)]; + var $11259=$st; + var $11260=(($11259+4)|0); + var $11261=$11260; + var $11262=HEAP16[(($11261)>>1)]; + var $11263=(($11262)&65535); + var $11264=(($11258+($11263<<2))|0); + var $11265=$11264; + var $11266=$11265; + var $11267=HEAP32[(($11266)>>2)]; + var $11268=(($11255+($11267<<2))|0); + var $11269=$11268; + $ptr11=$11269; + var $11270=$2; + var $11271=(($11270+64)|0); + var $11272=HEAP32[(($11271)>>2)]; + var $11273=$st; + var $11274=(($11273+2)|0); + var $11275=$11274; + var $11276=HEAP16[(($11275)>>1)]; + var $11277=(($11276)&65535); + var $11278=(($11272+($11277<<2))|0); + var $11279=$11278; + var $11280=$11279; + var $11281=(($11280)|0); + var $11282=HEAP32[(($11281)>>2)]; + var $11283=$ptr11; + var $11284=$11283; + var $11285=(($11284)|0); + HEAP32[(($11285)>>2)]=$11282; + var $11286=$2; + var $11287=(($11286+64)|0); + var $11288=HEAP32[(($11287)>>2)]; + var $11289=$st; + var $11290=(($11289+2)|0); + var $11291=$11290; + var $11292=HEAP16[(($11291)>>1)]; + var $11293=(($11292)&65535); + var $11294=(($11288+($11293<<2))|0); + var $11295=$11294; + var $11296=$11295; + var $11297=(($11296+4)|0); + var $11298=HEAP32[(($11297)>>2)]; + var $11299=$ptr11; + var $11300=$11299; + var $11301=(($11300+4)|0); + HEAP32[(($11301)>>2)]=$11298; + var $11302=$2; + var $11303=(($11302+64)|0); + var $11304=HEAP32[(($11303)>>2)]; + var $11305=$st; + var $11306=(($11305+2)|0); + var $11307=$11306; + var $11308=HEAP16[(($11307)>>1)]; + var $11309=(($11308)&65535); + var $11310=(($11304+($11309<<2))|0); + var $11311=$11310; + var $11312=$11311; + var $11313=(($11312+8)|0); + var $11314=HEAP32[(($11313)>>2)]; + var $11315=$ptr11; + var $11316=$11315; + var $11317=(($11316+8)|0); + HEAP32[(($11317)>>2)]=$11314; + __label__ = 487; break; + case 440: + var $11319=$2; + var $11320=(($11319+64)|0); + var $11321=HEAP32[(($11320)>>2)]; + var $11322=$st; + var $11323=(($11322+2)|0); + var $11324=$11323; + var $11325=HEAP16[(($11324)>>1)]; + var $11326=(($11325)&65535); + var $11327=(($11321+($11326<<2))|0); + var $11328=$11327; + var $11329=$11328; + var $11330=HEAP32[(($11329)>>2)]; + var $11331=$11330 & 2147483647; + var $11332=(($11331)|0)!=0; + var $11333=$11332 ^ 1; + var $11334=(($11333)&1); + var $11335=(($11334)|0); + var $11336=$2; + var $11337=(($11336+64)|0); + var $11338=HEAP32[(($11337)>>2)]; + var $11339=$st; + var $11340=(($11339+6)|0); + var $11341=$11340; + var $11342=HEAP16[(($11341)>>1)]; + var $11343=(($11342)&65535); + var $11344=(($11338+($11343<<2))|0); + var $11345=$11344; + var $11346=$11345; + HEAPF32[(($11346)>>2)]=$11335; + __label__ = 487; break; + case 441: + var $11348=$2; + var $11349=(($11348+64)|0); + var $11350=HEAP32[(($11349)>>2)]; + var $11351=$st; + var $11352=(($11351+2)|0); + var $11353=$11352; + var $11354=HEAP16[(($11353)>>1)]; + var $11355=(($11354)&65535); + var $11356=(($11350+($11355<<2))|0); + var $11357=$11356; + var $11358=$11357; + var $11359=(($11358)|0); + var $11360=HEAPF32[(($11359)>>2)]; + var $11361=$11360 != 0; + if ($11361) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 442; break; } + case 442: + var $11363=$2; + var $11364=(($11363+64)|0); + var $11365=HEAP32[(($11364)>>2)]; + var $11366=$st; + var $11367=(($11366+2)|0); + var $11368=$11367; + var $11369=HEAP16[(($11368)>>1)]; + var $11370=(($11369)&65535); + var $11371=(($11365+($11370<<2))|0); + var $11372=$11371; + var $11373=$11372; + var $11374=(($11373+4)|0); + var $11375=HEAPF32[(($11374)>>2)]; + var $11376=$11375 != 0; + if ($11376) { var $11394 = 0;__label__ = 444; break; } else { __label__ = 443; break; } + case 443: + var $11378=$2; + var $11379=(($11378+64)|0); + var $11380=HEAP32[(($11379)>>2)]; + var $11381=$st; + var $11382=(($11381+2)|0); + var $11383=$11382; + var $11384=HEAP16[(($11383)>>1)]; + var $11385=(($11384)&65535); + var $11386=(($11380+($11385<<2))|0); + var $11387=$11386; + var $11388=$11387; + var $11389=(($11388+8)|0); + var $11390=HEAPF32[(($11389)>>2)]; + var $11391=$11390 != 0; + var $11392=$11391 ^ 1; + var $11394 = $11392;__label__ = 444; break; + case 444: + var $11394; + var $11395=(($11394)&1); + var $11396=(($11395)|0); + var $11397=$2; + var $11398=(($11397+64)|0); + var $11399=HEAP32[(($11398)>>2)]; + var $11400=$st; + var $11401=(($11400+6)|0); + var $11402=$11401; + var $11403=HEAP16[(($11402)>>1)]; + var $11404=(($11403)&65535); + var $11405=(($11399+($11404<<2))|0); + var $11406=$11405; + var $11407=$11406; + HEAPF32[(($11407)>>2)]=$11396; + __label__ = 487; break; + case 445: + var $11409=$2; + var $11410=(($11409+64)|0); + var $11411=HEAP32[(($11410)>>2)]; + var $11412=$st; + var $11413=(($11412+2)|0); + var $11414=$11413; + var $11415=HEAP16[(($11414)>>1)]; + var $11416=(($11415)&65535); + var $11417=(($11411+($11416<<2))|0); + var $11418=$11417; + var $11419=$11418; + var $11420=HEAP32[(($11419)>>2)]; + var $11421=(($11420)|0)!=0; + if ($11421) { __label__ = 446; break; } else { var $11441 = 1;__label__ = 447; break; } + case 446: + var $11423=$2; + var $11424=$2; + var $11425=(($11424+64)|0); + var $11426=HEAP32[(($11425)>>2)]; + var $11427=$st; + var $11428=(($11427+2)|0); + var $11429=$11428; + var $11430=HEAP16[(($11429)>>1)]; + var $11431=(($11430)&65535); + var $11432=(($11426+($11431<<2))|0); + var $11433=$11432; + var $11434=$11433; + var $11435=HEAP32[(($11434)>>2)]; + var $11436=_prog_getstring($11423, $11435); + var $11437=HEAP8[($11436)]; + var $11438=(($11437 << 24) >> 24)!=0; + var $11439=$11438 ^ 1; + var $11441 = $11439;__label__ = 447; break; + case 447: + var $11441; + var $11442=(($11441)&1); + var $11443=(($11442)|0); + var $11444=$2; + var $11445=(($11444+64)|0); + var $11446=HEAP32[(($11445)>>2)]; + var $11447=$st; + var $11448=(($11447+6)|0); + var $11449=$11448; + var $11450=HEAP16[(($11449)>>1)]; + var $11451=(($11450)&65535); + var $11452=(($11446+($11451<<2))|0); + var $11453=$11452; + var $11454=$11453; + HEAPF32[(($11454)>>2)]=$11443; + __label__ = 487; break; + case 448: + var $11456=$2; + var $11457=(($11456+64)|0); + var $11458=HEAP32[(($11457)>>2)]; + var $11459=$st; + var $11460=(($11459+2)|0); + var $11461=$11460; + var $11462=HEAP16[(($11461)>>1)]; + var $11463=(($11462)&65535); + var $11464=(($11458+($11463<<2))|0); + var $11465=$11464; + var $11466=$11465; + var $11467=HEAP32[(($11466)>>2)]; + var $11468=(($11467)|0)==0; + var $11469=(($11468)&1); + var $11470=(($11469)|0); + var $11471=$2; + var $11472=(($11471+64)|0); + var $11473=HEAP32[(($11472)>>2)]; + var $11474=$st; + var $11475=(($11474+6)|0); + var $11476=$11475; + var $11477=HEAP16[(($11476)>>1)]; + var $11478=(($11477)&65535); + var $11479=(($11473+($11478<<2))|0); + var $11480=$11479; + var $11481=$11480; + HEAPF32[(($11481)>>2)]=$11470; + __label__ = 487; break; + case 449: + var $11483=$2; + var $11484=(($11483+64)|0); + var $11485=HEAP32[(($11484)>>2)]; + var $11486=$st; + var $11487=(($11486+2)|0); + var $11488=$11487; + var $11489=HEAP16[(($11488)>>1)]; + var $11490=(($11489)&65535); + var $11491=(($11485+($11490<<2))|0); + var $11492=$11491; + var $11493=$11492; + var $11494=HEAP32[(($11493)>>2)]; + var $11495=(($11494)|0)!=0; + var $11496=$11495 ^ 1; + var $11497=(($11496)&1); + var $11498=(($11497)|0); + var $11499=$2; + var $11500=(($11499+64)|0); + var $11501=HEAP32[(($11500)>>2)]; + var $11502=$st; + var $11503=(($11502+6)|0); + var $11504=$11503; + var $11505=HEAP16[(($11504)>>1)]; + var $11506=(($11505)&65535); + var $11507=(($11501+($11506<<2))|0); + var $11508=$11507; + var $11509=$11508; + HEAPF32[(($11509)>>2)]=$11498; + __label__ = 487; break; + case 450: + var $11511=$2; + var $11512=(($11511+64)|0); + var $11513=HEAP32[(($11512)>>2)]; + var $11514=$st; + var $11515=(($11514+2)|0); + var $11516=$11515; + var $11517=HEAP16[(($11516)>>1)]; + var $11518=(($11517)&65535); + var $11519=(($11513+($11518<<2))|0); + var $11520=$11519; + var $11521=$11520; + var $11522=HEAP32[(($11521)>>2)]; + var $11523=$11522 & 2147483647; + var $11524=(($11523)|0)!=0; + if ($11524) { __label__ = 451; break; } else { __label__ = 454; break; } + case 451: + var $11526=$st; + var $11527=(($11526+4)|0); + var $11528=$11527; + var $11529=HEAP16[(($11528)>>1)]; + var $11530=(($11529 << 16) >> 16); + var $11531=((($11530)-(1))|0); + var $11532=$st; + var $11533=(($11532+($11531<<3))|0); + $st=$11533; + var $11534=$jumpcount; + var $11535=((($11534)+(1))|0); + $jumpcount=$11535; + var $11536=$5; + var $11537=(($11535)|0) >= (($11536)|0); + if ($11537) { __label__ = 452; break; } else { __label__ = 453; break; } + case 452: + var $11539=$2; + var $11540=$2; + var $11541=(($11540)|0); + var $11542=HEAP32[(($11541)>>2)]; + var $11543=$jumpcount; + _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)); + __label__ = 453; break; + case 453: + __label__ = 454; break; + case 454: + __label__ = 487; break; + case 455: + var $11547=$2; + var $11548=(($11547+64)|0); + var $11549=HEAP32[(($11548)>>2)]; + var $11550=$st; + var $11551=(($11550+2)|0); + var $11552=$11551; + var $11553=HEAP16[(($11552)>>1)]; + var $11554=(($11553)&65535); + var $11555=(($11549+($11554<<2))|0); + var $11556=$11555; + var $11557=$11556; + var $11558=HEAP32[(($11557)>>2)]; + var $11559=$11558 & 2147483647; + var $11560=(($11559)|0)!=0; + if ($11560) { __label__ = 459; break; } else { __label__ = 456; break; } + case 456: + var $11562=$st; + var $11563=(($11562+4)|0); + var $11564=$11563; + var $11565=HEAP16[(($11564)>>1)]; + var $11566=(($11565 << 16) >> 16); + var $11567=((($11566)-(1))|0); + var $11568=$st; + var $11569=(($11568+($11567<<3))|0); + $st=$11569; + var $11570=$jumpcount; + var $11571=((($11570)+(1))|0); + $jumpcount=$11571; + var $11572=$5; + var $11573=(($11571)|0) >= (($11572)|0); + if ($11573) { __label__ = 457; break; } else { __label__ = 458; break; } + case 457: + var $11575=$2; + var $11576=$2; + var $11577=(($11576)|0); + var $11578=HEAP32[(($11577)>>2)]; + var $11579=$jumpcount; + _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)); + __label__ = 458; break; + case 458: + __label__ = 459; break; + case 459: + __label__ = 487; break; + case 460: + var $11583=$st; + var $11584=(($11583)|0); + var $11585=HEAP16[(($11584)>>1)]; + var $11586=(($11585)&65535); + var $11587=((($11586)-(51))|0); + var $11588=$2; + var $11589=(($11588+184)|0); + HEAP32[(($11589)>>2)]=$11587; + var $11590=$2; + var $11591=(($11590+64)|0); + var $11592=HEAP32[(($11591)>>2)]; + var $11593=$st; + var $11594=(($11593+2)|0); + var $11595=$11594; + var $11596=HEAP16[(($11595)>>1)]; + var $11597=(($11596)&65535); + var $11598=(($11592+($11597<<2))|0); + var $11599=$11598; + var $11600=$11599; + var $11601=HEAP32[(($11600)>>2)]; + var $11602=(($11601)|0)!=0; + if ($11602) { __label__ = 462; break; } else { __label__ = 461; break; } + case 461: + var $11604=$2; + var $11605=$2; + var $11606=(($11605)|0); + var $11607=HEAP32[(($11606)>>2)]; + _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)); + __label__ = 462; break; + case 462: + var $11609=$2; + var $11610=(($11609+64)|0); + var $11611=HEAP32[(($11610)>>2)]; + var $11612=$st; + var $11613=(($11612+2)|0); + var $11614=$11613; + var $11615=HEAP16[(($11614)>>1)]; + var $11616=(($11615)&65535); + var $11617=(($11611+($11616<<2))|0); + var $11618=$11617; + var $11619=$11618; + var $11620=HEAP32[(($11619)>>2)]; + var $11621=(($11620)|0)!=0; + if ($11621) { __label__ = 463; break; } else { __label__ = 464; break; } + case 463: + var $11623=$2; + var $11624=(($11623+64)|0); + var $11625=HEAP32[(($11624)>>2)]; + var $11626=$st; + var $11627=(($11626+2)|0); + var $11628=$11627; + var $11629=HEAP16[(($11628)>>1)]; + var $11630=(($11629)&65535); + var $11631=(($11625+($11630<<2))|0); + var $11632=$11631; + var $11633=$11632; + var $11634=HEAP32[(($11633)>>2)]; + var $11635=$2; + var $11636=(($11635+44)|0); + var $11637=HEAP32[(($11636)>>2)]; + var $11638=(($11634)>>>0) >= (($11637)>>>0); + if ($11638) { __label__ = 464; break; } else { __label__ = 465; break; } + case 464: + var $11640=$2; + var $11641=$2; + var $11642=(($11641)|0); + var $11643=HEAP32[(($11642)>>2)]; + _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)); + __label__ = 488; break; + case 465: + var $11645=$2; + var $11646=(($11645+64)|0); + var $11647=HEAP32[(($11646)>>2)]; + var $11648=$st; + var $11649=(($11648+2)|0); + var $11650=$11649; + var $11651=HEAP16[(($11650)>>1)]; + var $11652=(($11651)&65535); + var $11653=(($11647+($11652<<2))|0); + var $11654=$11653; + var $11655=$11654; + var $11656=HEAP32[(($11655)>>2)]; + var $11657=$2; + var $11658=(($11657+40)|0); + var $11659=HEAP32[(($11658)>>2)]; + var $11660=(($11659+($11656)*(36))|0); + $newf9=$11660; + var $11661=$newf9; + var $11662=(($11661+12)|0); + var $11663=HEAP32[(($11662)>>2)]; + var $11664=((($11663)+(1))|0); + HEAP32[(($11662)>>2)]=$11664; + var $11665=$st; + var $11666=$2; + var $11667=(($11666+4)|0); + var $11668=HEAP32[(($11667)>>2)]; + var $11669=$11665; + var $11670=$11668; + var $11671=((($11669)-($11670))|0); + var $11672=((((($11671)|0))/(8))&-1); + var $11673=((($11672)+(1))|0); + var $11674=$2; + var $11675=(($11674+176)|0); + HEAP32[(($11675)>>2)]=$11673; + var $11676=$newf9; + var $11677=(($11676)|0); + var $11678=HEAP32[(($11677)>>2)]; + var $11679=(($11678)|0) < 0; + if ($11679) { __label__ = 466; break; } else { __label__ = 471; break; } + case 466: + var $11681=$newf9; + var $11682=(($11681)|0); + var $11683=HEAP32[(($11682)>>2)]; + var $11684=(((-$11683))|0); + $builtinnumber12=$11684; + var $11685=$builtinnumber12; + var $11686=$2; + var $11687=(($11686+132)|0); + var $11688=HEAP32[(($11687)>>2)]; + var $11689=(($11685)>>>0) < (($11688)>>>0); + if ($11689) { __label__ = 467; break; } else { __label__ = 469; break; } + case 467: + var $11691=$builtinnumber12; + var $11692=$2; + var $11693=(($11692+128)|0); + var $11694=HEAP32[(($11693)>>2)]; + var $11695=(($11694+($11691<<2))|0); + var $11696=HEAP32[(($11695)>>2)]; + var $11697=(($11696)|0)!=0; + if ($11697) { __label__ = 468; break; } else { __label__ = 469; break; } + case 468: + var $11699=$builtinnumber12; + var $11700=$2; + var $11701=(($11700+128)|0); + var $11702=HEAP32[(($11701)>>2)]; + var $11703=(($11702+($11699<<2))|0); + var $11704=HEAP32[(($11703)>>2)]; + var $11705=$2; + var $11706=FUNCTION_TABLE[$11704]($11705); + __label__ = 470; break; + case 469: + var $11708=$2; + var $11709=$builtinnumber12; + var $11710=$2; + var $11711=(($11710)|0); + var $11712=HEAP32[(($11711)>>2)]; + _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)); + __label__ = 470; break; + case 470: + __label__ = 472; break; + case 471: + var $11715=$2; + var $11716=(($11715+4)|0); + var $11717=HEAP32[(($11716)>>2)]; + var $11718=$2; + var $11719=$newf9; + var $11720=_prog_enterfunction($11718, $11719); + var $11721=(($11717+($11720<<3))|0); + var $11722=((($11721)-(8))|0); + $st=$11722; + __label__ = 472; break; + case 472: + var $11724=$2; + var $11725=(($11724+112)|0); + var $11726=HEAP32[(($11725)>>2)]; + var $11727=(($11726)|0)!=0; + if ($11727) { __label__ = 473; break; } else { __label__ = 474; break; } + case 473: + __label__ = 488; break; + case 474: + __label__ = 487; break; + case 475: + var $11731=$2; + var $11732=$2; + var $11733=(($11732)|0); + var $11734=HEAP32[(($11733)>>2)]; + _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)); + __label__ = 487; break; + case 476: + var $11736=$st; + var $11737=(($11736+2)|0); + var $11738=$11737; + var $11739=HEAP16[(($11738)>>1)]; + var $11740=(($11739 << 16) >> 16); + var $11741=((($11740)-(1))|0); + var $11742=$st; + var $11743=(($11742+($11741<<3))|0); + $st=$11743; + var $11744=$jumpcount; + var $11745=((($11744)+(1))|0); + $jumpcount=$11745; + var $11746=(($11745)|0)==10000000; + if ($11746) { __label__ = 477; break; } else { __label__ = 478; break; } + case 477: + var $11748=$2; + var $11749=$2; + var $11750=(($11749)|0); + var $11751=HEAP32[(($11750)>>2)]; + var $11752=$jumpcount; + _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)); + __label__ = 478; break; + case 478: + __label__ = 487; break; + case 479: + var $11755=$2; + var $11756=(($11755+64)|0); + var $11757=HEAP32[(($11756)>>2)]; + var $11758=$st; + var $11759=(($11758+2)|0); + var $11760=$11759; + var $11761=HEAP16[(($11760)>>1)]; + var $11762=(($11761)&65535); + var $11763=(($11757+($11762<<2))|0); + var $11764=$11763; + var $11765=$11764; + var $11766=HEAP32[(($11765)>>2)]; + var $11767=$11766 & 2147483647; + var $11768=(($11767)|0)!=0; + if ($11768) { __label__ = 480; break; } else { var $11785 = 0;__label__ = 481; break; } + case 480: + var $11770=$2; + var $11771=(($11770+64)|0); + var $11772=HEAP32[(($11771)>>2)]; + var $11773=$st; + var $11774=(($11773+4)|0); + var $11775=$11774; + var $11776=HEAP16[(($11775)>>1)]; + var $11777=(($11776)&65535); + var $11778=(($11772+($11777<<2))|0); + var $11779=$11778; + var $11780=$11779; + var $11781=HEAP32[(($11780)>>2)]; + var $11782=$11781 & 2147483647; + var $11783=(($11782)|0)!=0; + var $11785 = $11783;__label__ = 481; break; + case 481: + var $11785; + var $11786=(($11785)&1); + var $11787=(($11786)|0); + var $11788=$2; + var $11789=(($11788+64)|0); + var $11790=HEAP32[(($11789)>>2)]; + var $11791=$st; + var $11792=(($11791+6)|0); + var $11793=$11792; + var $11794=HEAP16[(($11793)>>1)]; + var $11795=(($11794)&65535); + var $11796=(($11790+($11795<<2))|0); + var $11797=$11796; + var $11798=$11797; + HEAPF32[(($11798)>>2)]=$11787; + __label__ = 487; break; + case 482: + var $11800=$2; + var $11801=(($11800+64)|0); + var $11802=HEAP32[(($11801)>>2)]; + var $11803=$st; + var $11804=(($11803+2)|0); + var $11805=$11804; + var $11806=HEAP16[(($11805)>>1)]; + var $11807=(($11806)&65535); + var $11808=(($11802+($11807<<2))|0); + var $11809=$11808; + var $11810=$11809; + var $11811=HEAP32[(($11810)>>2)]; + var $11812=$11811 & 2147483647; + var $11813=(($11812)|0)!=0; + if ($11813) { var $11830 = 1;__label__ = 484; break; } else { __label__ = 483; break; } + case 483: + var $11815=$2; + var $11816=(($11815+64)|0); + var $11817=HEAP32[(($11816)>>2)]; + var $11818=$st; + var $11819=(($11818+4)|0); + var $11820=$11819; + var $11821=HEAP16[(($11820)>>1)]; + var $11822=(($11821)&65535); + var $11823=(($11817+($11822<<2))|0); + var $11824=$11823; + var $11825=$11824; + var $11826=HEAP32[(($11825)>>2)]; + var $11827=$11826 & 2147483647; + var $11828=(($11827)|0)!=0; + var $11830 = $11828;__label__ = 484; break; + case 484: + var $11830; + var $11831=(($11830)&1); + var $11832=(($11831)|0); + var $11833=$2; + var $11834=(($11833+64)|0); + var $11835=HEAP32[(($11834)>>2)]; + var $11836=$st; + var $11837=(($11836+6)|0); + var $11838=$11837; + var $11839=HEAP16[(($11838)>>1)]; + var $11840=(($11839)&65535); + var $11841=(($11835+($11840<<2))|0); + var $11842=$11841; + var $11843=$11842; + HEAPF32[(($11843)>>2)]=$11832; + __label__ = 487; break; + case 485: + var $11845=$2; + var $11846=(($11845+64)|0); + var $11847=HEAP32[(($11846)>>2)]; + var $11848=$st; + var $11849=(($11848+2)|0); + var $11850=$11849; + var $11851=HEAP16[(($11850)>>1)]; + var $11852=(($11851)&65535); + var $11853=(($11847+($11852<<2))|0); + var $11854=$11853; + var $11855=$11854; + var $11856=HEAPF32[(($11855)>>2)]; + var $11857=(($11856)&-1); + var $11858=$2; + var $11859=(($11858+64)|0); + var $11860=HEAP32[(($11859)>>2)]; + var $11861=$st; + var $11862=(($11861+4)|0); + var $11863=$11862; + var $11864=HEAP16[(($11863)>>1)]; + var $11865=(($11864)&65535); + var $11866=(($11860+($11865<<2))|0); + var $11867=$11866; + var $11868=$11867; + var $11869=HEAPF32[(($11868)>>2)]; + var $11870=(($11869)&-1); + var $11871=$11857 & $11870; + var $11872=(($11871)|0); + var $11873=$2; + var $11874=(($11873+64)|0); + var $11875=HEAP32[(($11874)>>2)]; + var $11876=$st; + var $11877=(($11876+6)|0); + var $11878=$11877; + var $11879=HEAP16[(($11878)>>1)]; + var $11880=(($11879)&65535); + var $11881=(($11875+($11880<<2))|0); + var $11882=$11881; + var $11883=$11882; + HEAPF32[(($11883)>>2)]=$11872; + __label__ = 487; break; + case 486: + var $11885=$2; + var $11886=(($11885+64)|0); + var $11887=HEAP32[(($11886)>>2)]; + var $11888=$st; + var $11889=(($11888+2)|0); + var $11890=$11889; + var $11891=HEAP16[(($11890)>>1)]; + var $11892=(($11891)&65535); + var $11893=(($11887+($11892<<2))|0); + var $11894=$11893; + var $11895=$11894; + var $11896=HEAPF32[(($11895)>>2)]; + var $11897=(($11896)&-1); + var $11898=$2; + var $11899=(($11898+64)|0); + var $11900=HEAP32[(($11899)>>2)]; + var $11901=$st; + var $11902=(($11901+4)|0); + var $11903=$11902; + var $11904=HEAP16[(($11903)>>1)]; + var $11905=(($11904)&65535); + var $11906=(($11900+($11905<<2))|0); + var $11907=$11906; + var $11908=$11907; + var $11909=HEAPF32[(($11908)>>2)]; + var $11910=(($11909)&-1); + var $11911=$11897 | $11910; + var $11912=(($11911)|0); + var $11913=$2; + var $11914=(($11913+64)|0); + var $11915=HEAP32[(($11914)>>2)]; + var $11916=$st; + var $11917=(($11916+6)|0); + var $11918=$11917; + var $11919=HEAP16[(($11918)>>1)]; + var $11920=(($11919)&65535); + var $11921=(($11915+($11920<<2))|0); + var $11922=$11921; + var $11923=$11922; + HEAPF32[(($11923)>>2)]=$11912; + __label__ = 487; break; + case 487: + __label__ = 368; break; + case 488: + var $11926=$oldxflags; + var $11927=$2; + var $11928=(($11927+180)|0); + HEAP32[(($11928)>>2)]=$11926; + var $11929=$2; + var $11930=(($11929+156)|0); + HEAP32[(($11930)>>2)]=0; + var $11931=$2; + var $11932=(($11931+168)|0); + HEAP32[(($11932)>>2)]=0; + var $11933=$2; + var $11934=(($11933+112)|0); + var $11935=HEAP32[(($11934)>>2)]; + var $11936=(($11935)|0)!=0; + if ($11936) { __label__ = 489; break; } else { __label__ = 490; break; } + case 489: + $1=0; + __label__ = 491; break; + case 490: + $1=1; + __label__ = 491; break; + case 491: + var $11940=$1; + STACKTOP = __stackBase__; + return $11940; + default: assert(0, "bad label: " + __label__); + } +} +_prog_exec["X"]=1; + +function _qcvmerror($prog, $fmt) { + var __stackBase__ = STACKTOP; STACKTOP += 4; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + + var $1; + var $2; + var $ap=__stackBase__; + $1=$prog; + $2=$fmt; + var $3=$1; + var $4=(($3+112)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=((($5)+(1))|0); + HEAP32[(($4)>>2)]=$6; + var $7=$ap; + HEAP32[(($7)>>2)]=arguments[_qcvmerror.length]; + var $8=$2; + var $9=HEAP32[(($ap)>>2)]; + var $10=_vprintf($8, $9); + var $11=$ap; + ; + var $12=HEAP32[((_stdout)>>2)]; + var $13=_putc(10, $12); + STACKTOP = __stackBase__; + return; +} + + +function _prog_print_statement($prog, $st) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $t=__stackBase__; + $1=$prog; + $2=$st; + var $3=$2; + var $4=(($3)|0); + var $5=HEAP16[(($4)>>1)]; + var $6=(($5)&65535); + var $7=(($6)>>>0) >= 67; + if ($7) { __label__ = 3; break; } else { __label__ = 4; break; } + case 3: + var $9=$2; + var $10=(($9)|0); + var $11=HEAP16[(($10)>>1)]; + var $12=(($11)&65535); + 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)); + __label__ = 42; break; + case 4: + var $15=$2; + var $16=(($15)|0); + var $17=HEAP16[(($16)>>1)]; + var $18=(($17)&65535); + var $19=((_asm_instr+($18)*(12))|0); + var $20=(($19)|0); + var $21=HEAP32[(($20)>>2)]; + 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)); + var $23=$2; + var $24=(($23)|0); + var $25=HEAP16[(($24)>>1)]; + var $26=(($25)&65535); + var $27=(($26)|0) >= 49; + if ($27) { __label__ = 5; break; } else { __label__ = 7; break; } + case 5: + var $29=$2; + var $30=(($29)|0); + var $31=HEAP16[(($30)>>1)]; + var $32=(($31)&65535); + var $33=(($32)|0) <= 50; + if ($33) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + var $35=$1; + var $36=$2; + var $37=(($36+2)|0); + var $38=$37; + var $39=HEAP16[(($38)>>1)]; + var $40=(($39)&65535); + _trace_print_global($35, $40, 2); + var $41=$2; + var $42=(($41+4)|0); + var $43=$42; + var $44=HEAP16[(($43)>>1)]; + var $45=(($44 << 16) >> 16); + 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)); + __label__ = 41; break; + case 7: + var $48=$2; + var $49=(($48)|0); + var $50=HEAP16[(($49)>>1)]; + var $51=(($50)&65535); + var $52=(($51)|0) >= 51; + if ($52) { __label__ = 8; break; } else { __label__ = 10; break; } + case 8: + var $54=$2; + var $55=(($54)|0); + var $56=HEAP16[(($55)>>1)]; + var $57=(($56)&65535); + var $58=(($57)|0) <= 59; + if ($58) { __label__ = 9; break; } else { __label__ = 10; break; } + case 9: + 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)); + __label__ = 40; break; + case 10: + var $62=$2; + var $63=(($62)|0); + var $64=HEAP16[(($63)>>1)]; + var $65=(($64)&65535); + var $66=(($65)|0)==61; + if ($66) { __label__ = 11; break; } else { __label__ = 12; break; } + case 11: + var $68=$2; + var $69=(($68+2)|0); + var $70=$69; + var $71=HEAP16[(($70)>>1)]; + var $72=(($71 << 16) >> 16); + 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)); + __label__ = 39; break; + case 12: + var $75=$t; + 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)]; + var $76=$2; + var $77=(($76)|0); + var $78=HEAP16[(($77)>>1)]; + var $79=(($78)&65535); + if ((($79)|0) == 3) { + __label__ = 13; break; + } + else if ((($79)|0) == 4) { + __label__ = 14; break; + } + else if ((($79)|0) == 2) { + __label__ = 15; break; + } + else if ((($79)|0) == 7 || (($79)|0) == 9 || (($79)|0) == 11 || (($79)|0) == 16) { + __label__ = 16; break; + } + else if ((($79)|0) == 12 || (($79)|0) == 17) { + __label__ = 17; break; + } + else if ((($79)|0) == 31 || (($79)|0) == 37) { + __label__ = 18; break; + } + else if ((($79)|0) == 32) { + __label__ = 19; break; + } + else if ((($79)|0) == 33) { + __label__ = 20; break; + } + else if ((($79)|0) == 34) { + __label__ = 21; break; + } + else if ((($79)|0) == 35) { + __label__ = 22; break; + } + else if ((($79)|0) == 36) { + __label__ = 23; break; + } + else if ((($79)|0) == 38) { + __label__ = 24; break; + } + else if ((($79)|0) == 39) { + __label__ = 25; break; + } + else if ((($79)|0) == 40) { + __label__ = 26; break; + } + else if ((($79)|0) == 41) { + __label__ = 27; break; + } + else if ((($79)|0) == 42) { + __label__ = 28; break; + } + else { + __label__ = 29; break; + } + + case 13: + var $81=(($t+8)|0); + HEAP32[(($81)>>2)]=3; + var $82=(($t+4)|0); + HEAP32[(($82)>>2)]=3; + __label__ = 29; break; + case 14: + var $84=(($t+8)|0); + HEAP32[(($84)>>2)]=3; + var $85=(($t)|0); + HEAP32[(($85)>>2)]=3; + __label__ = 29; break; + case 15: + var $87=(($t+4)|0); + HEAP32[(($87)>>2)]=3; + var $88=(($t)|0); + HEAP32[(($88)>>2)]=3; + __label__ = 29; break; + case 16: + var $90=(($t+8)|0); + HEAP32[(($90)>>2)]=3; + var $91=(($t+4)|0); + HEAP32[(($91)>>2)]=3; + var $92=(($t)|0); + HEAP32[(($92)>>2)]=3; + __label__ = 29; break; + case 17: + var $94=(($t+4)|0); + HEAP32[(($94)>>2)]=1; + var $95=(($t)|0); + HEAP32[(($95)>>2)]=1; + __label__ = 29; break; + case 18: + var $97=(($t+8)|0); + HEAP32[(($97)>>2)]=-1; + __label__ = 29; break; + case 19: + var $99=(($t+4)|0); + HEAP32[(($99)>>2)]=3; + var $100=(($t)|0); + HEAP32[(($100)>>2)]=3; + var $101=(($t+8)|0); + HEAP32[(($101)>>2)]=-1; + __label__ = 29; break; + case 20: + var $103=(($t+4)|0); + HEAP32[(($103)>>2)]=1; + var $104=(($t)|0); + HEAP32[(($104)>>2)]=1; + var $105=(($t+8)|0); + HEAP32[(($105)>>2)]=-1; + __label__ = 29; break; + case 21: + var $107=(($t+4)|0); + HEAP32[(($107)>>2)]=4; + var $108=(($t)|0); + HEAP32[(($108)>>2)]=4; + var $109=(($t+8)|0); + HEAP32[(($109)>>2)]=-1; + __label__ = 29; break; + case 22: + var $111=(($t+4)|0); + HEAP32[(($111)>>2)]=5; + var $112=(($t)|0); + HEAP32[(($112)>>2)]=5; + var $113=(($t+8)|0); + HEAP32[(($113)>>2)]=-1; + __label__ = 29; break; + case 23: + var $115=(($t+4)|0); + HEAP32[(($115)>>2)]=6; + var $116=(($t)|0); + HEAP32[(($116)>>2)]=6; + var $117=(($t+8)|0); + HEAP32[(($117)>>2)]=-1; + __label__ = 29; break; + case 24: + var $119=(($t)|0); + HEAP32[(($119)>>2)]=3; + var $120=(($t+4)|0); + HEAP32[(($120)>>2)]=4; + var $121=(($t+8)|0); + HEAP32[(($121)>>2)]=-1; + __label__ = 29; break; + case 25: + var $123=(($t)|0); + HEAP32[(($123)>>2)]=1; + var $124=(($t+4)|0); + HEAP32[(($124)>>2)]=4; + var $125=(($t+8)|0); + HEAP32[(($125)>>2)]=-1; + __label__ = 29; break; + case 26: + var $127=(($t)|0); + HEAP32[(($127)>>2)]=4; + var $128=(($t+4)|0); + HEAP32[(($128)>>2)]=4; + var $129=(($t+8)|0); + HEAP32[(($129)>>2)]=-1; + __label__ = 29; break; + case 27: + var $131=(($t)|0); + HEAP32[(($131)>>2)]=5; + var $132=(($t+4)|0); + HEAP32[(($132)>>2)]=4; + var $133=(($t+8)|0); + HEAP32[(($133)>>2)]=-1; + __label__ = 29; break; + case 28: + var $135=(($t)|0); + HEAP32[(($135)>>2)]=6; + var $136=(($t+4)|0); + HEAP32[(($136)>>2)]=4; + var $137=(($t+8)|0); + HEAP32[(($137)>>2)]=-1; + __label__ = 29; break; + case 29: + var $139=(($t)|0); + var $140=HEAP32[(($139)>>2)]; + var $141=(($140)|0) >= 0; + if ($141) { __label__ = 30; break; } else { __label__ = 31; break; } + case 30: + var $143=$1; + var $144=$2; + var $145=(($144+2)|0); + var $146=$145; + var $147=HEAP16[(($146)>>1)]; + var $148=(($147)&65535); + var $149=(($t)|0); + var $150=HEAP32[(($149)>>2)]; + _trace_print_global($143, $148, $150); + __label__ = 32; break; + case 31: + 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)); + __label__ = 32; break; + case 32: + var $154=(($t+4)|0); + var $155=HEAP32[(($154)>>2)]; + var $156=(($155)|0) >= 0; + if ($156) { __label__ = 33; break; } else { __label__ = 34; break; } + case 33: + var $158=$1; + var $159=$2; + var $160=(($159+4)|0); + var $161=$160; + var $162=HEAP16[(($161)>>1)]; + var $163=(($162)&65535); + var $164=(($t+4)|0); + var $165=HEAP32[(($164)>>2)]; + _trace_print_global($158, $163, $165); + __label__ = 35; break; + case 34: + 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)); + __label__ = 35; break; + case 35: + var $169=(($t+8)|0); + var $170=HEAP32[(($169)>>2)]; + var $171=(($170)|0) >= 0; + if ($171) { __label__ = 36; break; } else { __label__ = 37; break; } + case 36: + var $173=$1; + var $174=$2; + var $175=(($174+6)|0); + var $176=$175; + var $177=HEAP16[(($176)>>1)]; + var $178=(($177)&65535); + var $179=(($t+8)|0); + var $180=HEAP32[(($179)>>2)]; + _trace_print_global($173, $178, $180); + __label__ = 38; break; + case 37: + 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)); + __label__ = 38; break; + case 38: + 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)); + __label__ = 39; break; + case 39: + __label__ = 40; break; + case 40: + __label__ = 41; break; + case 41: + var $188=HEAP32[((_stdout)>>2)]; + var $189=_fflush($188); + __label__ = 42; break; + case 42: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_prog_print_statement["X"]=1; + +function _trace_print_global($prog, $glob, $vtype) { + var __stackBase__ = STACKTOP; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $3; + var $def; + var $value; + var $len; + var $name; + $1=$prog; + $2=$glob; + $3=$vtype; + var $4=$2; + var $5=(($4)|0)!=0; + if ($5) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + 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)); + $len=$7; + __label__ = 17; break; + case 4: + var $9=$1; + var $10=$2; + var $11=_prog_getdef($9, $10); + $def=$11; + var $12=$2; + var $13=$1; + var $14=(($13+64)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=(($15+($12<<2))|0); + var $17=$16; + $value=$17; + var $18=$def; + var $19=(($18)|0)!=0; + if ($19) { __label__ = 5; break; } else { __label__ = 9; break; } + case 5: + var $21=$1; + var $22=$def; + var $23=(($22+4)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=_prog_getstring($21, $24); + $name=$25; + var $26=$name; + var $27=(($26)|0); + var $28=HEAP8[($27)]; + var $29=(($28 << 24) >> 24); + var $30=(($29)|0)==35; + if ($30) { __label__ = 6; break; } else { __label__ = 7; break; } + case 6: + 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)); + $len=$32; + __label__ = 8; break; + case 7: + var $34=$name; + 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)); + $len=$35; + __label__ = 8; break; + case 8: + var $37=$def; + var $38=(($37)|0); + var $39=HEAP16[(($38)>>1)]; + var $40=(($39)&65535); + $3=$40; + __label__ = 10; break; + case 9: + var $42=$2; + 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)); + $len=$43; + __label__ = 10; break; + case 10: + var $45=$3; + if ((($45)|0) == 0 || (($45)|0) == 4 || (($45)|0) == 5 || (($45)|0) == 6 || (($45)|0) == 7) { + __label__ = 11; break; + } + else if ((($45)|0) == 3) { + __label__ = 12; break; + } + else if ((($45)|0) == 1) { + __label__ = 13; break; + } + else if ((($45)|0) == 2) { + __label__ = 14; break; + } + else { + __label__ = 15; break; + } + + case 11: + var $47=$value; + var $48=$47; + var $49=HEAP32[(($48)>>2)]; + 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)); + var $51=$len; + var $52=((($51)+($50))|0); + $len=$52; + __label__ = 16; break; + case 12: + var $54=$value; + var $55=$54; + var $56=(($55)|0); + var $57=HEAPF32[(($56)>>2)]; + var $58=$57; + var $59=$value; + var $60=$59; + var $61=(($60+4)|0); + var $62=HEAPF32[(($61)>>2)]; + var $63=$62; + var $64=$value; + var $65=$64; + var $66=(($65+8)|0); + var $67=HEAPF32[(($66)>>2)]; + var $68=$67; + 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)); + var $70=$len; + var $71=((($70)+($69))|0); + $len=$71; + __label__ = 16; break; + case 13: + var $73=$1; + var $74=$value; + var $75=$74; + var $76=HEAP32[(($75)>>2)]; + var $77=_prog_getstring($73, $76); + var $78=$len; + var $79=(((29)-($78))|0); + var $80=((($79)-(5))|0); + var $81=_print_escaped_string($77, $80); + var $82=$len; + var $83=((($82)+($81))|0); + $len=$83; + 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)); + var $85=$len; + var $86=((($85)+($84))|0); + $len=$86; + __label__ = 16; break; + case 14: + __label__ = 15; break; + case 15: + var $89=$value; + var $90=$89; + var $91=HEAPF32[(($90)>>2)]; + var $92=$91; + 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)); + var $94=$len; + var $95=((($94)+($93))|0); + $len=$95; + __label__ = 16; break; + case 16: + __label__ = 17; break; + case 17: + var $98=$len; + var $99=(($98)>>>0) < 28; + if ($99) { __label__ = 18; break; } else { __label__ = 19; break; } + case 18: + var $101=$len; + var $102=(((28)-($101))|0); + var $103=((STRING_TABLE._trace_print_global_spaces+$102)|0); + HEAP8[($103)]=0; + 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)); + var $105=$len; + var $106=(((28)-($105))|0); + var $107=((STRING_TABLE._trace_print_global_spaces+$106)|0); + HEAP8[($107)]=32; + __label__ = 19; break; + case 19: + STACKTOP = __stackBase__; + return; + default: assert(0, "bad label: " + __label__); + } +} +_trace_print_global["X"]=1; + +function _print_escaped_string($str, $maxlen) { + ; + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $len; + $1=$str; + $2=$maxlen; + $len=2; + var $3=HEAP32[((_stdout)>>2)]; + var $4=_putc(34, $3); + var $5=$2; + var $6=((($5)-(1))|0); + $2=$6; + __label__ = 3; break; + case 3: + var $8=$1; + var $9=HEAP8[($8)]; + var $10=(($9 << 24) >> 24)!=0; + if ($10) { __label__ = 4; break; } else { __label__ = 18; break; } + case 4: + var $12=$len; + var $13=$2; + var $14=(($12)>>>0) >= (($13)>>>0); + if ($14) { __label__ = 5; break; } else { __label__ = 6; break; } + case 5: + var $16=HEAP32[((_stdout)>>2)]; + var $17=_putc(46, $16); + var $18=HEAP32[((_stdout)>>2)]; + var $19=_putc(46, $18); + var $20=HEAP32[((_stdout)>>2)]; + var $21=_putc(46, $20); + var $22=$len; + var $23=((($22)+(3))|0); + $len=$23; + __label__ = 18; break; + case 6: + var $25=$1; + var $26=HEAP8[($25)]; + var $27=(($26 << 24) >> 24); + if ((($27)|0) == 7) { + __label__ = 7; break; + } + else if ((($27)|0) == 8) { + __label__ = 8; break; + } + else if ((($27)|0) == 13) { + __label__ = 9; break; + } + else if ((($27)|0) == 10) { + __label__ = 10; break; + } + else if ((($27)|0) == 9) { + __label__ = 11; break; + } + else if ((($27)|0) == 12) { + __label__ = 12; break; + } + else if ((($27)|0) == 11) { + __label__ = 13; break; + } + else if ((($27)|0) == 92) { + __label__ = 14; break; + } + else if ((($27)|0) == 34) { + __label__ = 15; break; + } + else { + __label__ = 16; break; + } + + case 7: + var $29=$len; + var $30=((($29)+(2))|0); + $len=$30; + var $31=HEAP32[((_stdout)>>2)]; + var $32=_putc(92, $31); + var $33=HEAP32[((_stdout)>>2)]; + var $34=_putc(97, $33); + __label__ = 17; break; + case 8: + var $36=$len; + var $37=((($36)+(2))|0); + $len=$37; + var $38=HEAP32[((_stdout)>>2)]; + var $39=_putc(92, $38); + var $40=HEAP32[((_stdout)>>2)]; + var $41=_putc(98, $40); + __label__ = 17; break; + case 9: + var $43=$len; + var $44=((($43)+(2))|0); + $len=$44; + var $45=HEAP32[((_stdout)>>2)]; + var $46=_putc(92, $45); + var $47=HEAP32[((_stdout)>>2)]; + var $48=_putc(114, $47); + __label__ = 17; break; + case 10: + var $50=$len; + var $51=((($50)+(2))|0); + $len=$51; + var $52=HEAP32[((_stdout)>>2)]; + var $53=_putc(92, $52); + var $54=HEAP32[((_stdout)>>2)]; + var $55=_putc(110, $54); + __label__ = 17; break; + case 11: + var $57=$len; + var $58=((($57)+(2))|0); + $len=$58; + var $59=HEAP32[((_stdout)>>2)]; + var $60=_putc(92, $59); + var $61=HEAP32[((_stdout)>>2)]; + var $62=_putc(116, $61); + __label__ = 17; break; + case 12: + var $64=$len; + var $65=((($64)+(2))|0); + $len=$65; + var $66=HEAP32[((_stdout)>>2)]; + var $67=_putc(92, $66); + var $68=HEAP32[((_stdout)>>2)]; + var $69=_putc(102, $68); + __label__ = 17; break; + case 13: + var $71=$len; + var $72=((($71)+(2))|0); + $len=$72; + var $73=HEAP32[((_stdout)>>2)]; + var $74=_putc(92, $73); + var $75=HEAP32[((_stdout)>>2)]; + var $76=_putc(118, $75); + __label__ = 17; break; + case 14: + var $78=$len; + var $79=((($78)+(2))|0); + $len=$79; + var $80=HEAP32[((_stdout)>>2)]; + var $81=_putc(92, $80); + var $82=HEAP32[((_stdout)>>2)]; + var $83=_putc(92, $82); + __label__ = 17; break; + case 15: + var $85=$len; + var $86=((($85)+(2))|0); + $len=$86; + var $87=HEAP32[((_stdout)>>2)]; + var $88=_putc(92, $87); + var $89=HEAP32[((_stdout)>>2)]; + var $90=_putc(34, $89); + __label__ = 17; break; + case 16: + var $92=$len; + var $93=((($92)+(1))|0); + $len=$93; + var $94=$1; + var $95=HEAP8[($94)]; + var $96=(($95 << 24) >> 24); + var $97=HEAP32[((_stdout)>>2)]; + var $98=_putc($96, $97); + __label__ = 17; break; + case 17: + var $100=$1; + var $101=(($100+1)|0); + $1=$101; + __label__ = 3; break; + case 18: + var $103=HEAP32[((_stdout)>>2)]; + var $104=_putc(34, $103); + var $105=$len; + ; + return $105; + default: assert(0, "bad label: " + __label__); + } +} +_print_escaped_string["X"]=1; + +function _prog_enterfunction($prog, $func) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $2; + var $st=__stackBase__; + var $p; + var $parampos; + var $globals; + var $s; + $1=$prog; + $2=$func; + var $3=$1; + var $4=(($3+156)|0); + var $5=HEAP32[(($4)>>2)]; + var $6=(($st+4)|0); + HEAP32[(($6)>>2)]=$5; + var $7=$1; + var $8=(($7+176)|0); + var $9=HEAP32[(($8)>>2)]; + var $10=(($st)|0); + HEAP32[(($10)>>2)]=$9; + var $11=$2; + var $12=(($st+8)|0); + HEAP32[(($12)>>2)]=$11; + var $13=$1; + var $14=(($13+64)|0); + var $15=HEAP32[(($14)>>2)]; + var $16=$2; + var $17=(($16+4)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($15+($18<<2))|0); + $globals=$19; + var $20=$1; + var $21=$globals; + var $22=$2; + var $23=(($22+8)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=_qc_program_localstack_append($20, $21, $24); + if ($25) { __label__ = 4; break; } else { __label__ = 3; break; } + case 3: + 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)); + _exit(1); + throw "Reached an unreachable!" + case 4: + var $29=$2; + var $30=(($29+4)|0); + var $31=HEAP32[(($30)>>2)]; + $parampos=$31; + $p=0; + __label__ = 5; break; + case 5: + var $33=$p; + var $34=$2; + var $35=(($34+24)|0); + var $36=HEAP32[(($35)>>2)]; + var $37=(($33)>>>0) < (($36)>>>0); + if ($37) { __label__ = 6; break; } else { __label__ = 12; break; } + case 6: + $s=0; + __label__ = 7; break; + case 7: + var $40=$s; + var $41=$p; + var $42=$2; + var $43=(($42+28)|0); + var $44=(($43+$41)|0); + var $45=HEAP8[($44)]; + var $46=(($45)&255); + var $47=(($40)>>>0) < (($46)>>>0); + if ($47) { __label__ = 8; break; } else { __label__ = 10; break; } + case 8: + var $49=$p; + var $50=((($49)*(3))|0); + var $51=((($50)+(4))|0); + var $52=$s; + var $53=((($51)+($52))|0); + var $54=$1; + var $55=(($54+64)|0); + var $56=HEAP32[(($55)>>2)]; + var $57=(($56+($53<<2))|0); + var $58=HEAP32[(($57)>>2)]; + var $59=$parampos; + var $60=$1; + var $61=(($60+64)|0); + var $62=HEAP32[(($61)>>2)]; + var $63=(($62+($59<<2))|0); + HEAP32[(($63)>>2)]=$58; + var $64=$parampos; + var $65=((($64)+(1))|0); + $parampos=$65; + __label__ = 9; break; + case 9: + var $67=$s; + var $68=((($67)+(1))|0); + $s=$68; + __label__ = 7; break; + case 10: + __label__ = 11; break; + case 11: + var $71=$p; + var $72=((($71)+(1))|0); + $p=$72; + __label__ = 5; break; + case 12: + var $74=$1; + var $75=(($st)|0); + var $76=HEAP32[(($75)>>2)]; + var $77=(($st+4)|0); + var $78=HEAP32[(($77)>>2)]; + var $79=(($st+8)|0); + var $80=HEAP32[(($79)>>2)]; + var $81=_qc_program_stack_add($74, $76, $78, $80); + if ($81) { __label__ = 14; break; } else { __label__ = 13; break; } + case 13: + 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)); + _exit(1); + throw "Reached an unreachable!" + case 14: + var $85=$2; + var $86=(($85)|0); + var $87=HEAP32[(($86)>>2)]; + STACKTOP = __stackBase__; + return $87; + default: assert(0, "bad label: " + __label__); + } +} +_prog_enterfunction["X"]=1; + +function _prog_leavefunction($prog) { + var __stackBase__ = STACKTOP; STACKTOP += 12; assert(STACKTOP % 4 == 0, "Stack is unaligned"); assert(STACKTOP < STACK_MAX, "Ran out of stack"); + var __label__; + __label__ = 2; + while(1) switch(__label__) { + case 2: + var $1; + var $prev; + var $oldsp; + var $st=__stackBase__; + var $globals; + $1=$prog; + $prev=0; + var $2=$1; + var $3=(($2+168)|0); + var $4=HEAP32[(($3)>>2)]; + var $5=((($4)-(1))|0); + var $6=$1; + var $7=(($6+164)|0); + var $8=HEAP32[(($7)>>2)]; + var $9=(($8+($5)*(12))|0); + var $10=$st; + var $11=$9; + 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)]; + var $12=$1; + var $13=(($12+168)|0); + var $14=HEAP32[(($13)>>2)]; + var $15=((($14)-(1))|0); + var $16=$1; + var $17=(($16+164)|0); + var $18=HEAP32[(($17)>>2)]; + var $19=(($18+($15)*(12))|0); + var $20=(($19+8)|0); + var $21=HEAP32[(($20)>>2)]; + $prev=$21; + var $22=$1; + var $23=(($22+168)|0); + var $24=HEAP32[(($23)>>2)]; + var $25=((($24)-(1))|0); + var $26=$1; + var $27=(($26+164)|0); + var $28=HEAP32[(($27)>>2)]; + var $29=(($28+($25)*(12))|0); + var $30=(($29+4)|0); + var $31=HEAP32[(($30)>>2)]; + $oldsp=$31; + var $32=$prev; + var $33=(($32)|0)!=0; + if ($33) { __label__ = 3; break; } else { __label__ = 6; break; } + case 3: + var $35=$1; + var $36=(($35+64)|0); + var $37=HEAP32[(($36)>>2)]; + var $38=$prev; + var $39=(($38+4)|0); + var $40=HEAP32[(($39)>>2)]; + var $41=(($37+($40<<2))|0); + $globals=$41; + var $42=$globals; + var $43=$42; + var $44=$1; + var $45=(($44+152)|0); + var $46=HEAP32[(($45)>>2)]; + var $47=$oldsp; + var $48=(($46+($47<<2))|0); + var $49=$48; + var $50=$prev; + var $51=(($50+8)|0); + var $52=HEAP32[(($51)>>2)]; + assert($52 % 1 === 0, 'memcpy given ' + $52 + ' bytes to copy. Problem with quantum=1 corrections perhaps?');_memcpy($43, $49, $52, 4); + var $53=$1; + var $54=$oldsp; + var $55=_qc_program_localstack_resize($53, $54); + if ($55) { __label__ = 5; break; } else { __label__ = 4; break; } + case 4: + 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)); + _exit(1); + throw "Reached an unreachable!" + case 5: + __label__ = 6; break; + case 6: + var $60=$1; + var $61=$1; + var $62=(($61+168)|0); + var $63=HEAP32[(($62)>>2)]; + var $64=((($63)-(1))|0); + var $65=_qc_program_stack_remove($60, $64); + if ($65) { __label__ = 8; break; } else { __label__ = 7; break; } + case 7: + 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)); + _exit(1); + throw "Reached an unreachable!" + case 8: + var $69=(($st)|0); + var $70=HEAP32[(($69)>>2)]; + var $71=((($70)-(1))|0); + STACKTOP = __stackBase__; + return $71; + default: assert(0, "bad label: " + __label__); + } +} +_prog_leavefunction["X"]=1; + +// Note: Some Emscripten settings will significantly limit the speed of the generated code. +// Note: Some Emscripten settings may limit the speed of the generated code. +// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included +var i64Math = null; + + + function _memcpy(dest, src, num, align) { + assert(num % 1 === 0, 'memcpy given ' + num + ' bytes to copy. Problem with quantum=1 corrections perhaps?'); + if (num >= 20 && src % 2 == dest % 2) { + // This is unaligned, but quite large, and potentially alignable, so work hard to get to aligned settings + if (src % 4 == dest % 4) { + var stop = src + num; + while (src % 4) { // no need to check for stop, since we have large num + HEAP8[dest++] = HEAP8[src++]; + } + var src4 = src >> 2, dest4 = dest >> 2, stop4 = stop >> 2; + while (src4 < stop4) { + HEAP32[dest4++] = HEAP32[src4++]; + } + src = src4 << 2; + dest = dest4 << 2; + while (src < stop) { + HEAP8[dest++] = HEAP8[src++]; + } + } else { + var stop = src + num; + if (src % 2) { // no need to check for stop, since we have large num + HEAP8[dest++] = HEAP8[src++]; + } + var src2 = src >> 1, dest2 = dest >> 1, stop2 = stop >> 1; + while (src2 < stop2) { + HEAP16[dest2++] = HEAP16[src2++]; + } + src = src2 << 1; + dest = dest2 << 1; + if (src < stop) { + HEAP8[dest++] = HEAP8[src++]; + } + } + } else { + while (num--) { + HEAP8[dest++] = HEAP8[src++]; + } + } + }var _llvm_memcpy_p0i8_p0i8_i32=_memcpy; +var _util_memory_a; // stub for _util_memory_a +var _util_memory_d; // stub for _util_memory_d +var _util_fopen; // stub for _util_fopen + + + + 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}; + + function ___setErrNo(value) { + // For convenient setting and returning of errno. + if (!___setErrNo.ret) ___setErrNo.ret = allocate([0], 'i32', ALLOC_STATIC); + HEAP32[((___setErrNo.ret)>>2)]=value + return value; + } + + var _stdin=0; + + var _stdout=0; + + var _stderr=0; + + var __impure_ptr=0;var FS={currentPath:"/",nextInode:2,streams:[null],checkStreams:function () { + for (var i in FS.streams) assert(i >= 0 && i < FS.streams.length); // no keys not in dense span + for (var i = 0; i < FS.streams.length; i++) assert(typeof FS.streams[i] == 'object'); // no non-null holes in dense span + },ignorePermissions:true,joinPath:function (parts, forceRelative) { + var ret = parts[0]; + for (var i = 1; i < parts.length; i++) { + if (ret[ret.length-1] != '/') ret += '/'; + ret += parts[i]; + } + if (forceRelative && ret[0] == '/') ret = ret.substr(1); + return ret; + },absolutePath:function (relative, base) { + if (typeof relative !== 'string') return null; + if (base === undefined) base = FS.currentPath; + if (relative && relative[0] == '/') base = ''; + var full = base + '/' + relative; + var parts = full.split('/').reverse(); + var absolute = ['']; + while (parts.length) { + var part = parts.pop(); + if (part == '' || part == '.') { + // Nothing. + } else if (part == '..') { + if (absolute.length > 1) absolute.pop(); + } else { + absolute.push(part); + } + } + return absolute.length == 1 ? '/' : absolute.join('/'); + },analyzePath:function (path, dontResolveLastLink, linksVisited) { + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null + }; + path = FS.absolutePath(path); + if (path == '/') { + ret.isRoot = true; + ret.exists = ret.parentExists = true; + ret.name = '/'; + ret.path = ret.parentPath = '/'; + ret.object = ret.parentObject = FS.root; + } else if (path !== null) { + linksVisited = linksVisited || 0; + path = path.slice(1).split('/'); + var current = FS.root; + var traversed = ['']; + while (path.length) { + if (path.length == 1 && current.isFolder) { + ret.parentExists = true; + ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/'); + ret.parentObject = current; + ret.name = path[0]; + } + var target = path.shift(); + if (!current.isFolder) { + ret.error = ERRNO_CODES.ENOTDIR; + break; + } else if (!current.read) { + ret.error = ERRNO_CODES.EACCES; + break; + } else if (!current.contents.hasOwnProperty(target)) { + ret.error = ERRNO_CODES.ENOENT; + break; + } + current = current.contents[target]; + if (current.link && !(dontResolveLastLink && path.length == 0)) { + if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX. + ret.error = ERRNO_CODES.ELOOP; + break; + } + var link = FS.absolutePath(current.link, traversed.join('/')); + ret = FS.analyzePath([link].concat(path).join('/'), + dontResolveLastLink, linksVisited + 1); + return ret; + } + traversed.push(target); + if (path.length == 0) { + ret.exists = true; + ret.path = traversed.join('/'); + ret.object = current; + } + } + } + return ret; + },findObject:function (path, dontResolveLastLink) { + FS.ensureRoot(); + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + ___setErrNo(ret.error); + return null; + } + },createObject:function (parent, name, properties, canRead, canWrite) { + if (!parent) parent = '/'; + if (typeof parent === 'string') parent = FS.findObject(parent); + + if (!parent) { + ___setErrNo(ERRNO_CODES.EACCES); + throw new Error('Parent path must exist.'); + } + if (!parent.isFolder) { + ___setErrNo(ERRNO_CODES.ENOTDIR); + throw new Error('Parent must be a folder.'); + } + if (!parent.write && !FS.ignorePermissions) { + ___setErrNo(ERRNO_CODES.EACCES); + throw new Error('Parent folder must be writeable.'); + } + if (!name || name == '.' || name == '..') { + ___setErrNo(ERRNO_CODES.ENOENT); + throw new Error('Name must not be empty.'); + } + if (parent.contents.hasOwnProperty(name)) { + ___setErrNo(ERRNO_CODES.EEXIST); + throw new Error("Can't overwrite object."); + } + + parent.contents[name] = { + read: canRead === undefined ? true : canRead, + write: canWrite === undefined ? false : canWrite, + timestamp: Date.now(), + inodeNumber: FS.nextInode++ + }; + for (var key in properties) { + if (properties.hasOwnProperty(key)) { + parent.contents[name][key] = properties[key]; + } + } + + return parent.contents[name]; + },createFolder:function (parent, name, canRead, canWrite) { + var properties = {isFolder: true, isDevice: false, contents: {}}; + return FS.createObject(parent, name, properties, canRead, canWrite); + },createPath:function (parent, path, canRead, canWrite) { + var current = FS.findObject(parent); + if (current === null) throw new Error('Invalid parent.'); + path = path.split('/').reverse(); + while (path.length) { + var part = path.pop(); + if (!part) continue; + if (!current.contents.hasOwnProperty(part)) { + FS.createFolder(current, part, canRead, canWrite); + } + current = current.contents[part]; + } + return current; + },createFile:function (parent, name, properties, canRead, canWrite) { + properties.isFolder = false; + return FS.createObject(parent, name, properties, canRead, canWrite); + },createDataFile:function (parent, name, data, canRead, canWrite) { + if (typeof data === 'string') { + var dataArray = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i); + data = dataArray; + } + var properties = { + isDevice: false, + 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 + }; + return FS.createFile(parent, name, properties, canRead, canWrite); + },createLazyFile:function (parent, name, url, canRead, canWrite) { + + if (typeof XMLHttpRequest !== 'undefined') { + if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. + var LazyUint8Array = function(chunkSize, length) { + this.length = length; + this.chunkSize = chunkSize; + this.chunks = []; // Loaded chunks. Index is the chunk number + } + LazyUint8Array.prototype.get = function(idx) { + if (idx > this.length-1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % chunkSize; + var chunkNum = Math.floor(idx / chunkSize); + return this.getter(chunkNum)[chunkOffset]; + } + LazyUint8Array.prototype.setDataGetter = function(getter) { + this.getter = getter; + } + + // Find length + var xhr = new XMLHttpRequest(); + xhr.open('HEAD', url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var chunkSize = 1024*1024; // Chunk size in bytes + if (!hasByteServing) chunkSize = datalength; + + // Function to get a range from the remote URL. + var doXHR = (function(from, to) { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!"); + + // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available. + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + + // Some hints to the browser that we want binary data. + if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer'; + if (xhr.overrideMimeType) { + xhr.overrideMimeType('text/plain; charset=x-user-defined'); + } + + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []); + } else { + return intArrayFromString(xhr.responseText || '', true); + } + }); + + var lazyArray = new LazyUint8Array(chunkSize, datalength); + lazyArray.setDataGetter(function(chunkNum) { + var start = chunkNum * lazyArray.chunkSize; + var end = (chunkNum+1) * lazyArray.chunkSize - 1; // including this byte + end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end); + } + if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum]; + }); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + + return FS.createFile(parent, name, properties, canRead, canWrite); + },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) { + Browser.ensureObjects(); + var fullname = FS.joinPath([parent, name], true); + function processData(byteArray) { + function finish(byteArray) { + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite); + } + if (onload) onload(); + removeRunDependency('cp ' + fullname); + } + var handled = false; + Module['preloadPlugins'].forEach(function(plugin) { + if (handled) return; + if (plugin['canHandle'](fullname)) { + plugin['handle'](byteArray, fullname, finish, function() { + if (onerror) onerror(); + removeRunDependency('cp ' + fullname); + }); + handled = true; + } + }); + if (!handled) finish(byteArray); + } + addRunDependency('cp ' + fullname); + if (typeof url == 'string') { + Browser.asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + },createLink:function (parent, name, target, canRead, canWrite) { + var properties = {isDevice: false, link: target}; + return FS.createFile(parent, name, properties, canRead, canWrite); + },createDevice:function (parent, name, input, output) { + if (!(input || output)) { + throw new Error('A device must have at least one callback defined.'); + } + var ops = {isDevice: true, input: input, output: output}; + return FS.createFile(parent, name, ops, Boolean(input), Boolean(output)); + },forceLoadFile:function (obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + var success = true; + if (typeof XMLHttpRequest !== 'undefined') { + 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."); + } else if (Module['read']) { + // Command-line. + try { + // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as + // read() will try to parse UTF8. + obj.contents = intArrayFromString(Module['read'](obj.url), true); + } catch (e) { + success = false; + } + } else { + throw new Error('Cannot load without read() or XMLHttpRequest.'); + } + if (!success) ___setErrNo(ERRNO_CODES.EIO); + return success; + },ensureRoot:function () { + if (FS.root) return; + // The main file system tree. All the contents are inside this. + FS.root = { + read: true, + write: true, + isFolder: true, + isDevice: false, + timestamp: Date.now(), + inodeNumber: 1, + contents: {} + }; + },init:function (input, output, error) { + // Make sure we initialize only once. + 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)'); + FS.init.initialized = true; + + FS.ensureRoot(); + + // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here + input = input || Module['stdin']; + output = output || Module['stdout']; + error = error || Module['stderr']; + + // Default handlers. + var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true; + if (!input) { + stdinOverridden = false; + input = function() { + if (!input.cache || !input.cache.length) { + var result; + if (typeof window != 'undefined' && + typeof window.prompt == 'function') { + // Browser. + result = window.prompt('Input: '); + if (result === null) result = String.fromCharCode(0); // cancel ==> EOF + } else if (typeof readline == 'function') { + // Command line. + result = readline(); + } + if (!result) result = ''; + input.cache = intArrayFromString(result + '\n', true); + } + return input.cache.shift(); + }; + } + var utf8 = new Runtime.UTF8Processor(); + function simpleOutput(val) { + if (val === null || val === '\n'.charCodeAt(0)) { + output.printer(output.buffer.join('')); + output.buffer = []; + } else { + output.buffer.push(utf8.processCChar(val)); + } + } + if (!output) { + stdoutOverridden = false; + output = simpleOutput; + } + if (!output.printer) output.printer = Module['print']; + if (!output.buffer) output.buffer = []; + if (!error) { + stderrOverridden = false; + error = simpleOutput; + } + if (!error.printer) error.printer = Module['print']; + if (!error.buffer) error.buffer = []; + + // Create the temporary folder, if not already created + try { + FS.createFolder('/', 'tmp', true, true); + } catch(e) {} + + // Create the I/O devices. + var devFolder = FS.createFolder('/', 'dev', true, true); + var stdin = FS.createDevice(devFolder, 'stdin', input); + var stdout = FS.createDevice(devFolder, 'stdout', null, output); + var stderr = FS.createDevice(devFolder, 'stderr', null, error); + FS.createDevice(devFolder, 'tty', input, output); + + // Create default streams. + FS.streams[1] = { + path: '/dev/stdin', + object: stdin, + position: 0, + isRead: true, + isWrite: false, + isAppend: false, + isTerminal: !stdinOverridden, + error: false, + eof: false, + ungotten: [] + }; + FS.streams[2] = { + path: '/dev/stdout', + object: stdout, + position: 0, + isRead: false, + isWrite: true, + isAppend: false, + isTerminal: !stdoutOverridden, + error: false, + eof: false, + ungotten: [] + }; + FS.streams[3] = { + path: '/dev/stderr', + object: stderr, + position: 0, + isRead: false, + isWrite: true, + isAppend: false, + isTerminal: !stderrOverridden, + error: false, + eof: false, + ungotten: [] + }; + // Allocate these on the stack (and never free, we are called from ATINIT or earlier), to keep their locations low + _stdin = allocate([1], 'void*', ALLOC_STACK); + _stdout = allocate([2], 'void*', ALLOC_STACK); + _stderr = allocate([3], 'void*', ALLOC_STACK); + + // Other system paths + FS.createPath('/', 'dev/shm/tmp', true, true); // temp files + + // Newlib initialization + for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + 4; i++) { + FS.streams[i] = null; // Make sure to keep FS.streams dense + } + FS.streams[_stdin] = FS.streams[1]; + FS.streams[_stdout] = FS.streams[2]; + FS.streams[_stderr] = FS.streams[3]; + FS.checkStreams(); + assert(FS.streams.length < 1024); // at this early stage, we should not have a large set of file descriptors - just a few + __impure_ptr = allocate([ allocate( + [0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0], + 'void*', ALLOC_STATIC) ], 'void*', ALLOC_STATIC); + },quit:function () { + if (!FS.init.initialized) return; + // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed + if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output('\n'.charCodeAt(0)); + if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output('\n'.charCodeAt(0)); + },standardizePath:function (path) { + if (path.substr(0, 2) == './') path = path.substr(2); + return path; + },deleteFile:function (path) { + var path = FS.analyzePath(path); + if (!path.parentExists || !path.exists) { + throw 'Invalid path ' + path; + } + delete path.parentObject.contents[path.name]; + }}; + + + function _pread(fildes, buf, nbyte, offset) { + // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html + var stream = FS.streams[fildes]; + if (!stream || stream.object.isDevice) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isRead) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (stream.object.isFolder) { + ___setErrNo(ERRNO_CODES.EISDIR); + return -1; + } else if (nbyte < 0 || offset < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var bytesRead = 0; + while (stream.ungotten.length && nbyte > 0) { + HEAP8[(buf++)]=stream.ungotten.pop() + nbyte--; + bytesRead++; + } + var contents = stream.object.contents; + var size = Math.min(contents.length - offset, nbyte); + if (contents.subarray || contents.slice) { // typed array or normal array + for (var i = 0; i < size; i++) { + HEAP8[((buf)+(i))]=contents[offset + i] + } + } else { + for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR + HEAP8[((buf)+(i))]=contents.get(offset + i) + } + } + bytesRead += size; + return bytesRead; + } + }function _read(fildes, buf, nbyte) { + // ssize_t read(int fildes, void *buf, size_t nbyte); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html + var stream = FS.streams[fildes]; + if (!stream) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isRead) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (nbyte < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var bytesRead; + if (stream.object.isDevice) { + if (stream.object.input) { + bytesRead = 0; + while (stream.ungotten.length && nbyte > 0) { + HEAP8[(buf++)]=stream.ungotten.pop() + nbyte--; + bytesRead++; + } + for (var i = 0; i < nbyte; i++) { + try { + var result = stream.object.input(); + } catch (e) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + if (result === null || result === undefined) break; + bytesRead++; + HEAP8[((buf)+(i))]=result + } + return bytesRead; + } else { + ___setErrNo(ERRNO_CODES.ENXIO); + return -1; + } + } else { + var ungotSize = stream.ungotten.length; + bytesRead = _pread(fildes, buf, nbyte, stream.position); + if (bytesRead != -1) { + stream.position += (stream.ungotten.length - ungotSize) + bytesRead; + } + return bytesRead; + } + } + }function _fread(ptr, size, nitems, stream) { + // size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html + var bytesToRead = nitems * size; + if (bytesToRead == 0) return 0; + var bytesRead = _read(stream, ptr, bytesToRead); + var streamObj = FS.streams[stream]; + if (bytesRead == -1) { + if (streamObj) streamObj.error = true; + return 0; + } else { + if (bytesRead < bytesToRead) streamObj.eof = true; + return Math.floor(bytesRead / size); + } + } + + + function _close(fildes) { + // int close(int fildes); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html + if (FS.streams[fildes]) { + if (FS.streams[fildes].currentEntry) { + _free(FS.streams[fildes].currentEntry); + } + FS.streams[fildes] = null; + return 0; + } else { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } + } + + function _fsync(fildes) { + // int fsync(int fildes); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html + if (FS.streams[fildes]) { + // We write directly to the file system, so there's nothing to do here. + return 0; + } else { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } + }function _fclose(stream) { + // int fclose(FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html + _fsync(stream); + return _close(stream); + } + + + + + + function _pwrite(fildes, buf, nbyte, offset) { + // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html + var stream = FS.streams[fildes]; + if (!stream || stream.object.isDevice) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isWrite) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (stream.object.isFolder) { + ___setErrNo(ERRNO_CODES.EISDIR); + return -1; + } else if (nbyte < 0 || offset < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + var contents = stream.object.contents; + while (contents.length < offset) contents.push(0); + for (var i = 0; i < nbyte; i++) { + contents[offset + i] = HEAPU8[((buf)+(i))]; + } + stream.object.timestamp = Date.now(); + return i; + } + }function _write(fildes, buf, nbyte) { + // ssize_t write(int fildes, const void *buf, size_t nbyte); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html + var stream = FS.streams[fildes]; + if (!stream) { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } else if (!stream.isWrite) { + ___setErrNo(ERRNO_CODES.EACCES); + return -1; + } else if (nbyte < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + if (stream.object.isDevice) { + if (stream.object.output) { + for (var i = 0; i < nbyte; i++) { + try { + stream.object.output(HEAP8[((buf)+(i))]); + } catch (e) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + } + stream.object.timestamp = Date.now(); + return i; + } else { + ___setErrNo(ERRNO_CODES.ENXIO); + return -1; + } + } else { + var bytesWritten = _pwrite(fildes, buf, nbyte, stream.position); + if (bytesWritten != -1) stream.position += bytesWritten; + return bytesWritten; + } + } + }function _fwrite(ptr, size, nitems, stream) { + // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html + var bytesToWrite = nitems * size; + if (bytesToWrite == 0) return 0; + var bytesWritten = _write(stream, ptr, bytesToWrite); + if (bytesWritten == -1) { + if (FS.streams[stream]) FS.streams[stream].error = true; + return 0; + } else { + return Math.floor(bytesWritten / size); + } + } + + function __formatString(format, varargs) { + var textIndex = format; + var argIndex = 0; + function getNextArg(type) { + // NOTE: Explicitly ignoring type safety. Otherwise this fails: + // int x = 4; printf("%c\n", (char)x); + var ret; + if (type === 'double') { + ret = (tempDoubleI32[0]=HEAP32[(((varargs)+(argIndex))>>2)],tempDoubleI32[1]=HEAP32[(((varargs)+((argIndex)+(4)))>>2)],tempDoubleF64[0]); + } else if (type == 'i64') { + ret = [HEAP32[(((varargs)+(argIndex))>>2)], + HEAP32[(((varargs)+(argIndex+4))>>2)]]; + } else { + type = 'i32'; // varargs are always i32, i64, or double + ret = HEAP32[(((varargs)+(argIndex))>>2)]; + } + argIndex += Runtime.getNativeFieldSize(type); + return ret; + } + + var ret = []; + var curr, next, currArg; + while(1) { + var startTextIndex = textIndex; + curr = HEAP8[(textIndex)]; + if (curr === 0) break; + next = HEAP8[(textIndex+1)]; + if (curr == '%'.charCodeAt(0)) { + // Handle flags. + var flagAlwaysSigned = false; + var flagLeftAlign = false; + var flagAlternative = false; + var flagZeroPad = false; + flagsLoop: while (1) { + switch (next) { + case '+'.charCodeAt(0): + flagAlwaysSigned = true; + break; + case '-'.charCodeAt(0): + flagLeftAlign = true; + break; + case '#'.charCodeAt(0): + flagAlternative = true; + break; + case '0'.charCodeAt(0): + if (flagZeroPad) { + break flagsLoop; + } else { + flagZeroPad = true; + break; + } + default: + break flagsLoop; + } + textIndex++; + next = HEAP8[(textIndex+1)]; + } + + // Handle width. + var width = 0; + if (next == '*'.charCodeAt(0)) { + width = getNextArg('i32'); + textIndex++; + next = HEAP8[(textIndex+1)]; + } else { + while (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) { + width = width * 10 + (next - '0'.charCodeAt(0)); + textIndex++; + next = HEAP8[(textIndex+1)]; + } + } + + // Handle precision. + var precisionSet = false; + if (next == '.'.charCodeAt(0)) { + var precision = 0; + precisionSet = true; + textIndex++; + next = HEAP8[(textIndex+1)]; + if (next == '*'.charCodeAt(0)) { + precision = getNextArg('i32'); + textIndex++; + } else { + while(1) { + var precisionChr = HEAP8[(textIndex+1)]; + if (precisionChr < '0'.charCodeAt(0) || + precisionChr > '9'.charCodeAt(0)) break; + precision = precision * 10 + (precisionChr - '0'.charCodeAt(0)); + textIndex++; + } + } + next = HEAP8[(textIndex+1)]; + } else { + var precision = 6; // Standard default. + } + + // Handle integer sizes. WARNING: These assume a 32-bit architecture! + var argSize; + switch (String.fromCharCode(next)) { + case 'h': + var nextNext = HEAP8[(textIndex+2)]; + if (nextNext == 'h'.charCodeAt(0)) { + textIndex++; + argSize = 1; // char (actually i32 in varargs) + } else { + argSize = 2; // short (actually i32 in varargs) + } + break; + case 'l': + var nextNext = HEAP8[(textIndex+2)]; + if (nextNext == 'l'.charCodeAt(0)) { + textIndex++; + argSize = 8; // long long + } else { + argSize = 4; // long + } + break; + case 'L': // long long + case 'q': // int64_t + case 'j': // intmax_t + argSize = 8; + break; + case 'z': // size_t + case 't': // ptrdiff_t + case 'I': // signed ptrdiff_t or unsigned size_t + argSize = 4; + break; + default: + argSize = null; + } + if (argSize) textIndex++; + next = HEAP8[(textIndex+1)]; + + // Handle type specifier. + if (['d', 'i', 'u', 'o', 'x', 'X', 'p'].indexOf(String.fromCharCode(next)) != -1) { + // Integer. + var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0); + argSize = argSize || 4; + var currArg = getNextArg('i' + (argSize * 8)); + var origArg = currArg; + var argText; + // Flatten i64-1 [low, high] into a (slightly rounded) double + if (argSize == 8) { + currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0)); + } + // Truncate to requested size. + if (argSize <= 4) { + var limit = Math.pow(256, argSize) - 1; + currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8); + } + // Format the number. + var currAbsArg = Math.abs(currArg); + var prefix = ''; + if (next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0)) { + if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1]); else + argText = reSign(currArg, 8 * argSize, 1).toString(10); + } else if (next == 'u'.charCodeAt(0)) { + if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else + argText = unSign(currArg, 8 * argSize, 1).toString(10); + currArg = Math.abs(currArg); + } else if (next == 'o'.charCodeAt(0)) { + argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8); + } else if (next == 'x'.charCodeAt(0) || next == 'X'.charCodeAt(0)) { + prefix = flagAlternative ? '0x' : ''; + if (currArg < 0) { + // Represent negative numbers in hex as 2's complement. + currArg = -currArg; + argText = (currAbsArg - 1).toString(16); + var buffer = []; + for (var i = 0; i < argText.length; i++) { + buffer.push((0xF - parseInt(argText[i], 16)).toString(16)); + } + argText = buffer.join(''); + while (argText.length < argSize * 2) argText = 'f' + argText; + } else { + argText = currAbsArg.toString(16); + } + if (next == 'X'.charCodeAt(0)) { + prefix = prefix.toUpperCase(); + argText = argText.toUpperCase(); + } + } else if (next == 'p'.charCodeAt(0)) { + if (currAbsArg === 0) { + argText = '(nil)'; + } else { + prefix = '0x'; + argText = currAbsArg.toString(16); + } + } + if (precisionSet) { + while (argText.length < precision) { + argText = '0' + argText; + } + } + + // Add sign if needed + if (flagAlwaysSigned) { + if (currArg < 0) { + prefix = '-' + prefix; + } else { + prefix = '+' + prefix; + } + } + + // Add padding. + while (prefix.length + argText.length < width) { + if (flagLeftAlign) { + argText += ' '; + } else { + if (flagZeroPad) { + argText = '0' + argText; + } else { + prefix = ' ' + prefix; + } + } + } + + // Insert the result into the buffer. + argText = prefix + argText; + argText.split('').forEach(function(chr) { + ret.push(chr.charCodeAt(0)); + }); + } else if (['f', 'F', 'e', 'E', 'g', 'G'].indexOf(String.fromCharCode(next)) != -1) { + // Float. + var currArg = getNextArg('double'); + var argText; + + if (isNaN(currArg)) { + argText = 'nan'; + flagZeroPad = false; + } else if (!isFinite(currArg)) { + argText = (currArg < 0 ? '-' : '') + 'inf'; + flagZeroPad = false; + } else { + var isGeneral = false; + var effectivePrecision = Math.min(precision, 20); + + // Convert g/G to f/F or e/E, as per: + // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html + if (next == 'g'.charCodeAt(0) || next == 'G'.charCodeAt(0)) { + isGeneral = true; + precision = precision || 1; + var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10); + if (precision > exponent && exponent >= -4) { + next = ((next == 'g'.charCodeAt(0)) ? 'f' : 'F').charCodeAt(0); + precision -= exponent + 1; + } else { + next = ((next == 'g'.charCodeAt(0)) ? 'e' : 'E').charCodeAt(0); + precision--; + } + effectivePrecision = Math.min(precision, 20); + } + + if (next == 'e'.charCodeAt(0) || next == 'E'.charCodeAt(0)) { + argText = currArg.toExponential(effectivePrecision); + // Make sure the exponent has at least 2 digits. + if (/[eE][-+]\d$/.test(argText)) { + argText = argText.slice(0, -1) + '0' + argText.slice(-1); + } + } else if (next == 'f'.charCodeAt(0) || next == 'F'.charCodeAt(0)) { + argText = currArg.toFixed(effectivePrecision); + } + + var parts = argText.split('e'); + if (isGeneral && !flagAlternative) { + // Discard trailing zeros and periods. + while (parts[0].length > 1 && parts[0].indexOf('.') != -1 && + (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) { + parts[0] = parts[0].slice(0, -1); + } + } else { + // Make sure we have a period in alternative mode. + if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.'; + // Zero pad until required precision. + while (precision > effectivePrecision++) parts[0] += '0'; + } + argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : ''); + + // Capitalize 'E' if needed. + if (next == 'E'.charCodeAt(0)) argText = argText.toUpperCase(); + + // Add sign. + if (flagAlwaysSigned && currArg >= 0) { + argText = '+' + argText; + } + } + + // Add padding. + while (argText.length < width) { + if (flagLeftAlign) { + argText += ' '; + } else { + if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) { + argText = argText[0] + '0' + argText.slice(1); + } else { + argText = (flagZeroPad ? '0' : ' ') + argText; + } + } + } + + // Adjust case. + if (next < 'a'.charCodeAt(0)) argText = argText.toUpperCase(); + + // Insert the result into the buffer. + argText.split('').forEach(function(chr) { + ret.push(chr.charCodeAt(0)); + }); + } else if (next == 's'.charCodeAt(0)) { + // String. + var arg = getNextArg('i8*') || nullString; + var argLength = String_len(arg); + if (precisionSet) argLength = Math.min(argLength, precision); + if (!flagLeftAlign) { + while (argLength < width--) { + ret.push(' '.charCodeAt(0)); + } + } + for (var i = 0; i < argLength; i++) { + ret.push(HEAPU8[(arg++)]); + } + if (flagLeftAlign) { + while (argLength < width--) { + ret.push(' '.charCodeAt(0)); + } + } + } else if (next == 'c'.charCodeAt(0)) { + // Character. + if (flagLeftAlign) ret.push(getNextArg('i8')); + while (--width > 0) { + ret.push(' '.charCodeAt(0)); + } + if (!flagLeftAlign) ret.push(getNextArg('i8')); + } else if (next == 'n'.charCodeAt(0)) { + // Write the length written so far to the next parameter. + var ptr = getNextArg('i32*'); + HEAP32[((ptr)>>2)]=ret.length + } else if (next == '%'.charCodeAt(0)) { + // Literal percent sign. + ret.push(curr); + } else { + // Unknown specifiers remain untouched. + for (var i = startTextIndex; i < textIndex + 2; i++) { + ret.push(HEAP8[(i)]); + } + } + textIndex += 2; + // TODO: Support a/A (hex float) and m (last error) specifiers. + // TODO: Support %1${specifier} for arg selection. + } else { + ret.push(curr); + textIndex += 1; + } + } + return ret; + }function _fprintf(stream, format, varargs) { + // int fprintf(FILE *restrict stream, const char *restrict format, ...); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html + var result = __formatString(format, varargs); + var stack = Runtime.stackSave(); + var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream); + Runtime.stackRestore(stack); + return ret; + }function _printf(format, varargs) { + // int printf(const char *restrict format, ...); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html + var stdout = HEAP32[((_stdout)>>2)]; + return _fprintf(stdout, format, varargs); + } + + + function _memset(ptr, value, num, align) { + // TODO: make these settings, and in memcpy, {{'s + if (num >= 20) { + // This is unaligned, but quite large, so work hard to get to aligned settings + var stop = ptr + num; + while (ptr % 4) { // no need to check for stop, since we have large num + HEAP8[ptr++] = value; + } + if (value < 0) value += 256; // make it unsigned + var ptr4 = ptr >> 2, stop4 = stop >> 2, value4 = value | (value << 8) | (value << 16) | (value << 24); + while (ptr4 < stop4) { + HEAP32[ptr4++] = value4; + } + ptr = ptr4 << 2; + while (ptr < stop) { + HEAP8[ptr++] = value; + } + } else { + while (num--) { + HEAP8[ptr++] = value; + } + } + }var _llvm_memset_p0i8_i32=_memset; +var _util_strdup; // stub for _util_strdup + + + function _lseek(fildes, offset, whence) { + // off_t lseek(int fildes, off_t offset, int whence); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/lseek.html + if (FS.streams[fildes] && !FS.streams[fildes].object.isDevice) { + var stream = FS.streams[fildes]; + var position = offset; + if (whence === 1) { // SEEK_CUR. + position += stream.position; + } else if (whence === 2) { // SEEK_END. + position += stream.object.contents.length; + } + if (position < 0) { + ___setErrNo(ERRNO_CODES.EINVAL); + return -1; + } else { + stream.ungotten = []; + stream.position = position; + return position; + } + } else { + ___setErrNo(ERRNO_CODES.EBADF); + return -1; + } + }function _fseek(stream, offset, whence) { + // int fseek(FILE *stream, long offset, int whence); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fseek.html + var ret = _lseek(stream, offset, whence); + if (ret == -1) { + return -1; + } else { + FS.streams[stream].eof = false; + return 0; + } + } + + function _strlen(ptr) { + return String_len(ptr); + } + + + function _strncmp(px, py, n) { + var i = 0; + while (i < n) { + var x = HEAPU8[((px)+(i))]; + var y = HEAPU8[((py)+(i))]; + if (x == y && x == 0) return 0; + if (x == 0) return -1; + if (y == 0) return 1; + if (x == y) { + i ++; + continue; + } else { + return x > y ? 1 : -1; + } + } + return 0; + }function _strcmp(px, py) { + return _strncmp(px, py, TOTAL_MEMORY); + } + + function _fflush(stream) { + // int fflush(FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html + var flush = function(filedes) { + // Right now we write all data directly, except for output devices. + if (FS.streams[filedes] && FS.streams[filedes].object.output) { + if (!FS.streams[filedes].isTerminal) { // don't flush terminals, it would cause a \n to also appear + FS.streams[filedes].object.output(null); + } + } + }; + try { + if (stream === 0) { + for (var i = 0; i < FS.streams.length; i++) if (FS.streams[i]) flush(i); + } else { + flush(stream); + } + return 0; + } catch (e) { + ___setErrNo(ERRNO_CODES.EIO); + return -1; + } + } + + + function _fputc(c, stream) { + // int fputc(int c, FILE *stream); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html + var chr = unSign(c & 0xFF); + HEAP8[(_fputc.ret)]=chr + var ret = _write(stream, _fputc.ret, 1); + if (ret == -1) { + if (FS.streams[stream]) FS.streams[stream].error = true; + return -1; + } else { + return chr; + } + }var _putc=_fputc; + + + function __exit(status) { + // void _exit(int status); + // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html + + + exitRuntime(); + ABORT = true; + + throw 'exit(' + status + ') called, at ' + new Error().stack; + }function _exit(status) { + __exit(status); + } +var _llvm_va_start; // stub for _llvm_va_start + + var _vprintf=_printf; + + function _llvm_va_end() {} + + + function ___errno_location() { + return ___setErrNo.ret; + }var ___errno=___errno_location; + + + + 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) { + if (errnum in ERRNO_MESSAGES) { + if (ERRNO_MESSAGES[errnum].length > buflen - 1) { + return ___setErrNo(ERRNO_CODES.ERANGE); + } else { + var msg = ERRNO_MESSAGES[errnum]; + for (var i = 0; i < msg.length; i++) { + HEAP8[((strerrbuf)+(i))]=msg.charCodeAt(i) + } + HEAP8[((strerrbuf)+(i))]=0 + return 0; + } + } else { + return ___setErrNo(ERRNO_CODES.EINVAL); + } + }function _strerror(errnum) { + if (!_strerror.buffer) _strerror.buffer = _malloc(256); + _strerror_r(errnum, _strerror.buffer, 256); + return _strerror.buffer; + } + + + + function _malloc(bytes) { + /* Over-allocate to make sure it is byte-aligned by 8. + * This will leak memory, but this is only the dummy + * implementation (replaced by dlmalloc normally) so + * not an issue. + */ + ptr = Runtime.staticAlloc(bytes + 8); + return (ptr+8) & 0xFFFFFFF8; + } + Module["_malloc"] = _malloc; + + function _free(){} + Module["_free"] = _free; + + var Browser={mainLoop:{scheduler:null,shouldPause:false,paused:false,queue:[],pause:function () { + Browser.mainLoop.shouldPause = true; + },resume:function () { + if (Browser.mainLoop.paused) { + Browser.mainLoop.paused = false; + Browser.mainLoop.scheduler(); + } + Browser.mainLoop.shouldPause = false; + },updateStatus:function () { + if (Module['setStatus']) { + var message = Module['statusMessage'] || 'Please wait...'; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')'); + } else { + Module['setStatus'](message); + } + } else { + Module['setStatus'](''); + } + } + }},pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],ensureObjects:function () { + if (Browser.ensured) return; + Browser.ensured = true; + try { + new Blob(); + Browser.hasBlobConstructor = true; + } catch(e) { + Browser.hasBlobConstructor = false; + console.log("warning: no blob constructor, cannot create blobs with mimetypes"); + } + Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null)); + Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : console.log("warning: cannot create object URLs"); + + // Support for plugins that can process preloaded files. You can add more of these to + // your app by creating and appending to Module.preloadPlugins. + // + // Each plugin is asked if it can handle a file based on the file's name. If it can, + // it is given the file's raw data. When it is done, it calls a callback with the file's + // (possibly modified) data. For example, a plugin might decompress a file, or it + // might create some side data structure for use later (like an Image element, etc.). + + function getMimetype(name) { + return { + 'jpg': 'image/jpeg', + 'png': 'image/png', + 'bmp': 'image/bmp', + 'ogg': 'audio/ogg', + 'wav': 'audio/wav', + 'mp3': 'audio/mpeg' + }[name.substr(-3)]; + return ret; + } + + if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; + + var imagePlugin = {}; + imagePlugin['canHandle'] = function(name) { + return name.substr(-4) in { '.jpg': 1, '.png': 1, '.bmp': 1 }; + }; + imagePlugin['handle'] = function(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([byteArray], { type: getMimetype(name) }); + } catch(e) { + Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder'); + } + } + if (!b) { + var bb = new Browser.BlobBuilder(); + bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range + b = bb.getBlob(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == 'string', 'createObjectURL must return a url as a string'); + var img = new Image(); + img.onload = function() { + assert(img.complete, 'Image ' + name + ' could not be decoded'); + var canvas = document.createElement('canvas'); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext('2d'); + ctx.drawImage(img, 0, 0); + Module["preloadedImages"][name] = canvas; + Browser.URLObject.revokeObjectURL(url); + if (onload) onload(byteArray); + }; + img.onerror = function(event) { + console.log('Image ' + url + ' could not be decoded'); + if (onerror) onerror(); + }; + img.src = url; + }; + Module['preloadPlugins'].push(imagePlugin); + + var audioPlugin = {}; + audioPlugin['canHandle'] = function(name) { + return name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 }; + }; + audioPlugin['handle'] = function(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) return; + done = true; + Module["preloadedAudios"][name] = audio; + if (onload) onload(byteArray); + } + function fail() { + if (done) return; + done = true; + Module["preloadedAudios"][name] = new Audio(); // empty shim + if (onerror) onerror(); + } + if (Browser.hasBlobConstructor) { + try { + var b = new Blob([byteArray], { type: getMimetype(name) }); + } catch(e) { + return fail(); + } + var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this! + assert(typeof url == 'string', 'createObjectURL must return a url as a string'); + var audio = new Audio(); + audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926 + audio.onerror = function(event) { + if (done) return; + console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach'); + function encode64(data) { + var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + var PAD = '='; + var ret = ''; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = (leftchar << 8) | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = (leftchar >> (leftbits-6)) & 0x3f; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar&3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar&0xf) << 2]; + ret += PAD; + } + return ret; + } + audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray); + finish(audio); // we don't wait for confirmation this worked - but it's worth trying + }; + audio.src = url; + // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror + setTimeout(function() { + finish(audio); // try to use it even though it is not necessarily ready to play + }, 10000); + } else { + return fail(); + } + }; + Module['preloadPlugins'].push(audioPlugin); + },createContext:function (canvas, useWebGL, setInModule) { + try { + var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d'); + if (!ctx) throw ':('; + } catch (e) { + Module.print('Could not create canvas - ' + e); + return null; + } + if (useWebGL) { + // Set the background of the WebGL canvas to black + canvas.style.backgroundColor = "black"; + + // Warn on context loss + canvas.addEventListener('webglcontextlost', function(event) { + alert('WebGL context lost. You will need to reload the page.'); + }, false); + } + if (setInModule) { + Module.ctx = ctx; + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() }); + } + return ctx; + },requestFullScreen:function () { + var canvas = Module['canvas']; + function fullScreenChange() { + var isFullScreen = false; + if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] || + document['mozFullScreenElement'] || document['mozFullscreenElement'] || + document['fullScreenElement'] || document['fullscreenElement']) === canvas) { + canvas.requestPointerLock = canvas['requestPointerLock'] || + canvas['mozRequestPointerLock'] || + canvas['webkitRequestPointerLock']; + canvas.requestPointerLock(); + isFullScreen = true; + } + if (Module['onFullScreen']) Module['onFullScreen'](isFullScreen); + } + + document.addEventListener('fullscreenchange', fullScreenChange, false); + document.addEventListener('mozfullscreenchange', fullScreenChange, false); + document.addEventListener('webkitfullscreenchange', fullScreenChange, false); + + function pointerLockChange() { + Browser.pointerLock = document['pointerLockElement'] === canvas || + document['mozPointerLockElement'] === canvas || + document['webkitPointerLockElement'] === canvas; + } + + document.addEventListener('pointerlockchange', pointerLockChange, false); + document.addEventListener('mozpointerlockchange', pointerLockChange, false); + document.addEventListener('webkitpointerlockchange', pointerLockChange, false); + + canvas.requestFullScreen = canvas['requestFullScreen'] || + canvas['mozRequestFullScreen'] || + (canvas['webkitRequestFullScreen'] ? function() { canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null); + canvas.requestFullScreen(); + },requestAnimationFrame:function (func) { + if (!window.requestAnimationFrame) { + window.requestAnimationFrame = window['requestAnimationFrame'] || + window['mozRequestAnimationFrame'] || + window['webkitRequestAnimationFrame'] || + window['msRequestAnimationFrame'] || + window['oRequestAnimationFrame'] || + window['setTimeout']; + } + window.requestAnimationFrame(func); + },getMovementX:function (event) { + return event['movementX'] || + event['mozMovementX'] || + event['webkitMovementX'] || + 0; + },getMovementY:function (event) { + return event['movementY'] || + event['mozMovementY'] || + event['webkitMovementY'] || + 0; + },xhrLoad:function (url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function() { + if (xhr.status == 200) { + onload(xhr.response); + } else { + onerror(); + } + }; + xhr.onerror = onerror; + xhr.send(null); + },asyncLoad:function (url, onload, onerror) { + Browser.xhrLoad(url, function(arrayBuffer) { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + removeRunDependency('al ' + url); + }, function(event) { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }); + addRunDependency('al ' + url); + },resizeListeners:[],updateResizeListeners:function () { + var canvas = Module['canvas']; + Browser.resizeListeners.forEach(function(listener) { + listener(canvas.width, canvas.height); + }); + },setCanvasSize:function (width, height, noUpdates) { + var canvas = Module['canvas']; + canvas.width = width; + canvas.height = height; + if (!noUpdates) Browser.updateResizeListeners(); + }}; +__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; +___setErrNo(0); +_fputc.ret = allocate([0], "i8", ALLOC_STATIC); +Module["requestFullScreen"] = function() { Browser.requestFullScreen() }; + Module["requestAnimationFrame"] = function(func) { Browser.requestAnimationFrame(func) }; + Module["pauseMainLoop"] = function() { Browser.mainLoop.pause() }; + Module["resumeMainLoop"] = function() { Browser.mainLoop.resume() }; + + +// === Auto-generated postamble setup entry stuff === + +Module.callMain = function callMain(args) { + var argc = args.length+1; + function pad() { + for (var i = 0; i < 4-1; i++) { + argv.push(0); + } + } + var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ]; + pad(); + for (var i = 0; i < argc-1; i = i + 1) { + argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC)); + pad(); + } + argv.push(0); + argv = allocate(argv, 'i32', ALLOC_STATIC); + + return _main(argc, argv, 0); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var _asm_instr; + + + +var _prog_print_statement_t; + + +var _stdout; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +STRING_TABLE.__str=allocate([101,120,101,99,46,99,0] /* exec.c\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str1=allocate([114,98,0] /* rb\00 */, "i8", ALLOC_STATIC); +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); +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); +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); +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); +STRING_TABLE.__str6=allocate([115,101,101,107,32,102,97,105,108,101,100,0] /* seek failed\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str7=allocate([114,101,97,100,32,102,97,105,108,101,100,0] /* read failed\00 */, "i8", ALLOC_STATIC); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +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); +STRING_TABLE.__str28=allocate([32,60,62,32,37,45,49,50,115,0] /* __ %-12s\00 */, "i8", ALLOC_STATIC); +_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); +STRING_TABLE.__str29=allocate([37,100,10,0] /* %d\0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str30=allocate([10,0] /* \0A\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str31=allocate([37,105,10,0] /* %i\0A\00 */, "i8", ALLOC_STATIC); +_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); +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); +STRING_TABLE.__str33=allocate([40,110,111,110,101,41,0] /* (none)\00 */, "i8", ALLOC_STATIC); +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); +STRING_TABLE.__str34=allocate([60,110,117,108,108,62,44,0] /* _null_,\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str35=allocate([36,0] /* $\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str36=allocate([37,115,32,0] /* %s \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str37=allocate([91,64,37,117,93,32,0] /* [@%u] \00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str38=allocate([40,37,105,41,44,0] /* (%i),\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str39=allocate([39,37,103,32,37,103,32,37,103,39,44,0] /* '%g %g %g',\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str40=allocate([44,0] /* ,\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str41=allocate([37,103,44,0] /* %g,\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str42=allocate([68,79,78,69,0] /* DONE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str43=allocate([77,85,76,95,70,0] /* MUL_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str44=allocate([77,85,76,95,86,0] /* MUL_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str45=allocate([77,85,76,95,70,86,0] /* MUL_FV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str46=allocate([77,85,76,95,86,70,0] /* MUL_VF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str47=allocate([68,73,86,0] /* DIV\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str48=allocate([65,68,68,95,70,0] /* ADD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str49=allocate([65,68,68,95,86,0] /* ADD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str50=allocate([83,85,66,95,70,0] /* SUB_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str51=allocate([83,85,66,95,86,0] /* SUB_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str52=allocate([69,81,95,70,0] /* EQ_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str53=allocate([69,81,95,86,0] /* EQ_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str54=allocate([69,81,95,83,0] /* EQ_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str55=allocate([69,81,95,69,0] /* EQ_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str56=allocate([69,81,95,70,78,67,0] /* EQ_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str57=allocate([78,69,95,70,0] /* NE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str58=allocate([78,69,95,86,0] /* NE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str59=allocate([78,69,95,83,0] /* NE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str60=allocate([78,69,95,69,0] /* NE_E\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str61=allocate([78,69,95,70,78,67,0] /* NE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str62=allocate([76,69,0] /* LE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str63=allocate([71,69,0] /* GE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str64=allocate([76,84,0] /* LT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str65=allocate([71,84,0] /* GT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str66=allocate([70,73,69,76,68,95,70,0] /* FIELD_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str67=allocate([70,73,69,76,68,95,86,0] /* FIELD_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str68=allocate([70,73,69,76,68,95,83,0] /* FIELD_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str69=allocate([70,73,69,76,68,95,69,78,84,0] /* FIELD_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str70=allocate([70,73,69,76,68,95,70,76,68,0] /* FIELD_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str71=allocate([70,73,69,76,68,95,70,78,67,0] /* FIELD_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str72=allocate([65,68,68,82,69,83,83,0] /* ADDRESS\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str73=allocate([83,84,79,82,69,95,70,0] /* STORE_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str74=allocate([83,84,79,82,69,95,86,0] /* STORE_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str75=allocate([83,84,79,82,69,95,83,0] /* STORE_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str76=allocate([83,84,79,82,69,95,69,78,84,0] /* STORE_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str77=allocate([83,84,79,82,69,95,70,76,68,0] /* STORE_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str78=allocate([83,84,79,82,69,95,70,78,67,0] /* STORE_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str79=allocate([83,84,79,82,69,80,95,70,0] /* STOREP_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str80=allocate([83,84,79,82,69,80,95,86,0] /* STOREP_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str81=allocate([83,84,79,82,69,80,95,83,0] /* STOREP_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str82=allocate([83,84,79,82,69,80,95,69,78,84,0] /* STOREP_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str83=allocate([83,84,79,82,69,80,95,70,76,68,0] /* STOREP_FLD\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str84=allocate([83,84,79,82,69,80,95,70,78,67,0] /* STOREP_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str85=allocate([82,69,84,85,82,78,0] /* RETURN\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str86=allocate([78,79,84,95,70,0] /* NOT_F\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str87=allocate([78,79,84,95,86,0] /* NOT_V\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str88=allocate([78,79,84,95,83,0] /* NOT_S\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str89=allocate([78,79,84,95,69,78,84,0] /* NOT_ENT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str90=allocate([78,79,84,95,70,78,67,0] /* NOT_FNC\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str91=allocate([73,70,0] /* IF\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str92=allocate([73,70,78,79,84,0] /* IFNOT\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str93=allocate([67,65,76,76,48,0] /* CALL0\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str94=allocate([67,65,76,76,49,0] /* CALL1\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str95=allocate([67,65,76,76,50,0] /* CALL2\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str96=allocate([67,65,76,76,51,0] /* CALL3\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str97=allocate([67,65,76,76,52,0] /* CALL4\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str98=allocate([67,65,76,76,53,0] /* CALL5\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str99=allocate([67,65,76,76,54,0] /* CALL6\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str100=allocate([67,65,76,76,55,0] /* CALL7\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str101=allocate([67,65,76,76,56,0] /* CALL8\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str102=allocate([83,84,65,84,69,0] /* STATE\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str103=allocate([71,79,84,79,0] /* GOTO\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str104=allocate([65,78,68,0] /* AND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str105=allocate([79,82,0] /* OR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str106=allocate([66,73,84,65,78,68,0] /* BITAND\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str107=allocate([66,73,84,79,82,0] /* BITOR\00 */, "i8", ALLOC_STATIC); +STRING_TABLE.__str108=allocate([69,78,68,0] /* END\00 */, "i8", ALLOC_STATIC); +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); +STRING_TABLE.__str110=allocate([58,32,37,115,10,0] /* : %s\0A\00 */, "i8", ALLOC_STATIC); +HEAP32[((_asm_instr)>>2)]=((STRING_TABLE.__str42)|0); +HEAP32[(((_asm_instr)+(12))>>2)]=((STRING_TABLE.__str43)|0); +HEAP32[(((_asm_instr)+(24))>>2)]=((STRING_TABLE.__str44)|0); +HEAP32[(((_asm_instr)+(36))>>2)]=((STRING_TABLE.__str45)|0); +HEAP32[(((_asm_instr)+(48))>>2)]=((STRING_TABLE.__str46)|0); +HEAP32[(((_asm_instr)+(60))>>2)]=((STRING_TABLE.__str47)|0); +HEAP32[(((_asm_instr)+(72))>>2)]=((STRING_TABLE.__str48)|0); +HEAP32[(((_asm_instr)+(84))>>2)]=((STRING_TABLE.__str49)|0); +HEAP32[(((_asm_instr)+(96))>>2)]=((STRING_TABLE.__str50)|0); +HEAP32[(((_asm_instr)+(108))>>2)]=((STRING_TABLE.__str51)|0); +HEAP32[(((_asm_instr)+(120))>>2)]=((STRING_TABLE.__str52)|0); +HEAP32[(((_asm_instr)+(132))>>2)]=((STRING_TABLE.__str53)|0); +HEAP32[(((_asm_instr)+(144))>>2)]=((STRING_TABLE.__str54)|0); +HEAP32[(((_asm_instr)+(156))>>2)]=((STRING_TABLE.__str55)|0); +HEAP32[(((_asm_instr)+(168))>>2)]=((STRING_TABLE.__str56)|0); +HEAP32[(((_asm_instr)+(180))>>2)]=((STRING_TABLE.__str57)|0); +HEAP32[(((_asm_instr)+(192))>>2)]=((STRING_TABLE.__str58)|0); +HEAP32[(((_asm_instr)+(204))>>2)]=((STRING_TABLE.__str59)|0); +HEAP32[(((_asm_instr)+(216))>>2)]=((STRING_TABLE.__str60)|0); +HEAP32[(((_asm_instr)+(228))>>2)]=((STRING_TABLE.__str61)|0); +HEAP32[(((_asm_instr)+(240))>>2)]=((STRING_TABLE.__str62)|0); +HEAP32[(((_asm_instr)+(252))>>2)]=((STRING_TABLE.__str63)|0); +HEAP32[(((_asm_instr)+(264))>>2)]=((STRING_TABLE.__str64)|0); +HEAP32[(((_asm_instr)+(276))>>2)]=((STRING_TABLE.__str65)|0); +HEAP32[(((_asm_instr)+(288))>>2)]=((STRING_TABLE.__str66)|0); +HEAP32[(((_asm_instr)+(300))>>2)]=((STRING_TABLE.__str67)|0); +HEAP32[(((_asm_instr)+(312))>>2)]=((STRING_TABLE.__str68)|0); +HEAP32[(((_asm_instr)+(324))>>2)]=((STRING_TABLE.__str69)|0); +HEAP32[(((_asm_instr)+(336))>>2)]=((STRING_TABLE.__str70)|0); +HEAP32[(((_asm_instr)+(348))>>2)]=((STRING_TABLE.__str71)|0); +HEAP32[(((_asm_instr)+(360))>>2)]=((STRING_TABLE.__str72)|0); +HEAP32[(((_asm_instr)+(372))>>2)]=((STRING_TABLE.__str73)|0); +HEAP32[(((_asm_instr)+(384))>>2)]=((STRING_TABLE.__str74)|0); +HEAP32[(((_asm_instr)+(396))>>2)]=((STRING_TABLE.__str75)|0); +HEAP32[(((_asm_instr)+(408))>>2)]=((STRING_TABLE.__str76)|0); +HEAP32[(((_asm_instr)+(420))>>2)]=((STRING_TABLE.__str77)|0); +HEAP32[(((_asm_instr)+(432))>>2)]=((STRING_TABLE.__str78)|0); +HEAP32[(((_asm_instr)+(444))>>2)]=((STRING_TABLE.__str79)|0); +HEAP32[(((_asm_instr)+(456))>>2)]=((STRING_TABLE.__str80)|0); +HEAP32[(((_asm_instr)+(468))>>2)]=((STRING_TABLE.__str81)|0); +HEAP32[(((_asm_instr)+(480))>>2)]=((STRING_TABLE.__str82)|0); +HEAP32[(((_asm_instr)+(492))>>2)]=((STRING_TABLE.__str83)|0); +HEAP32[(((_asm_instr)+(504))>>2)]=((STRING_TABLE.__str84)|0); +HEAP32[(((_asm_instr)+(516))>>2)]=((STRING_TABLE.__str85)|0); +HEAP32[(((_asm_instr)+(528))>>2)]=((STRING_TABLE.__str86)|0); +HEAP32[(((_asm_instr)+(540))>>2)]=((STRING_TABLE.__str87)|0); +HEAP32[(((_asm_instr)+(552))>>2)]=((STRING_TABLE.__str88)|0); +HEAP32[(((_asm_instr)+(564))>>2)]=((STRING_TABLE.__str89)|0); +HEAP32[(((_asm_instr)+(576))>>2)]=((STRING_TABLE.__str90)|0); +HEAP32[(((_asm_instr)+(588))>>2)]=((STRING_TABLE.__str91)|0); +HEAP32[(((_asm_instr)+(600))>>2)]=((STRING_TABLE.__str92)|0); +HEAP32[(((_asm_instr)+(612))>>2)]=((STRING_TABLE.__str93)|0); +HEAP32[(((_asm_instr)+(624))>>2)]=((STRING_TABLE.__str94)|0); +HEAP32[(((_asm_instr)+(636))>>2)]=((STRING_TABLE.__str95)|0); +HEAP32[(((_asm_instr)+(648))>>2)]=((STRING_TABLE.__str96)|0); +HEAP32[(((_asm_instr)+(660))>>2)]=((STRING_TABLE.__str97)|0); +HEAP32[(((_asm_instr)+(672))>>2)]=((STRING_TABLE.__str98)|0); +HEAP32[(((_asm_instr)+(684))>>2)]=((STRING_TABLE.__str99)|0); +HEAP32[(((_asm_instr)+(696))>>2)]=((STRING_TABLE.__str100)|0); +HEAP32[(((_asm_instr)+(708))>>2)]=((STRING_TABLE.__str101)|0); +HEAP32[(((_asm_instr)+(720))>>2)]=((STRING_TABLE.__str102)|0); +HEAP32[(((_asm_instr)+(732))>>2)]=((STRING_TABLE.__str103)|0); +HEAP32[(((_asm_instr)+(744))>>2)]=((STRING_TABLE.__str104)|0); +HEAP32[(((_asm_instr)+(756))>>2)]=((STRING_TABLE.__str105)|0); +HEAP32[(((_asm_instr)+(768))>>2)]=((STRING_TABLE.__str106)|0); +HEAP32[(((_asm_instr)+(780))>>2)]=((STRING_TABLE.__str107)|0); +HEAP32[(((_asm_instr)+(792))>>2)]=((STRING_TABLE.__str108)|0); +FUNCTION_TABLE = [0,0]; Module["FUNCTION_TABLE"] = FUNCTION_TABLE; + + +function run(args) { + args = args || Module['arguments']; + + if (runDependencies > 0) { + Module.printErr('run() called, but dependencies remain, so not running'); + return 0; + } + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + var toRun = Module['preRun']; + Module['preRun'] = []; + for (var i = toRun.length-1; i >= 0; i--) { + toRun[i](); + } + if (runDependencies > 0) { + // a preRun added a dependency, run will be called later + return 0; + } + } + + function doRun() { + var ret = 0; + calledRun = true; + if (Module['_main']) { + preMain(); + ret = Module.callMain(args); + if (!Module['noExitRuntime']) { + exitRuntime(); + } + } + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length > 0) { + Module['postRun'].pop()(); + } + } + return ret; + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + return 0; + } else { + return doRun(); + } +} +Module['run'] = run; + +// {{PRE_RUN_ADDITIONS}} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +initRuntime(); + +var shouldRunNow = true; +if (Module['noInitialRun']) { + shouldRunNow = false; +} + +if (shouldRunNow) { + var ret = run(); +} + +// {{POST_RUN_ADDITIONS}} + + + + + + + // {{MODULE_ADDITIONS}} + + +// 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"] + diff --git a/qcvm b/qcvm new file mode 100755 index 0000000..7b6157b Binary files /dev/null and b/qcvm differ diff --git a/test.html b/test.html index a49d83c..90eaf35 100644 --- a/test.html +++ b/test.html @@ -8,7 +8,7 @@ - + - +